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

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

@@ -0,0 +1,11 @@
+import type { ProseDefaults, ProseDefaultsProviderProps } from './prose.types';
+/** What a region is set in here, before it states anything of its own. */
+export declare function useProseDefaults(): ProseDefaults;
+/**
+ * An application decides once how its rendered content reads — Typeset's
+ * presets, as a typed value rather than as a class. A region that states any
+ * of them itself still wins: an explicit prop is never overridden by context,
+ * and nesting a provider narrows the decision for one part of the page.
+ */
+export declare function ProseDefaultsProvider({ children, ...defaults }: ProseDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=prose-defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prose-defaults.d.ts","sourceRoot":"","sources":["../../../src/prose/prose-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAkB/E,0EAA0E;AAC1E,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,0BAA0B,+BAa1F"}

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

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+/**
+ * The content every scene on the reference page is set in. It stands in for
+ * what a Markdown renderer emits: bare tags, with no attribute the application
+ * ever got to write. Keeping it in one place is what makes two scenes
+ * comparable — a reader judging `flow` is looking at the same words twice.
+ */
+/** A stage the whole page uses: this family answers its own inline size. */
+export declare function Stage({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The opening of a document: a title, its permalink and a lead. */
+export declare function Opening(): import("react").JSX.Element;
+/** Two paragraphs and a list: enough to read a rhythm from. */
+export declare function Rhythm(): import("react").JSX.Element;
+/** Everything a Markdown renderer can emit, once. */
+export declare function Specimen(): import("react").JSX.Element;
+/** A table wider than any column this page gives it. */
+export declare function WideTable(): import("react").JSX.Element;
+//# sourceMappingURL=prose-demo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prose-demo.d.ts","sourceRoot":"","sources":["../../../src/prose/prose-demo.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC;;;;;GAKG;AAEH,4EAA4E;AAC5E,wBAAgB,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,+BAM1D;AAED,oEAAoE;AACpE,wBAAgB,OAAO,gCAmBtB;AAED,+DAA+D;AAC/D,wBAAgB,MAAM,gCAgBrB;AAED,qDAAqD;AACrD,wBAAgB,QAAQ,gCAsDvB;AAED,wDAAwD;AACxD,wBAAgB,SAAS,gCAwCxB"}

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

@@ -0,0 +1,34 @@
+import type { ProseAnchorProps, ProseExcludeProps, ProseFootnotesProps, ProseLeadProps } from './prose.types';
+/**
+ * The opening paragraph, one step up and in the muted tone. Tailwind's
+ * equivalent is a class the author writes into the Markdown; this is a part,
+ * so it is contract, it is selectable, and a renderer's component map can
+ * produce it.
+ */
+export declare function ProseLead({ render, ...nativeProps }: ProseLeadProps): 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 heading's permalink. The link itself is the consumer's —
+ * `rehype-autolink-headings` writes it — and the family owns where it sits,
+ * how large its target is, and the rule that it appears on hover **and** on
+ * focus. It is hidden with opacity, never with `display: none`, so a keyboard
+ * reader can reach it and a screen reader can announce it.
+ *
+ * A word joiner is written before it so the last word of a title and its
+ * permalink wrap together. It is the device `Link` uses for its external
+ * marker, and for the same reason: a no-break space would carry a full word
+ * space with it.
+ */
+export declare function ProseAnchor({ children, render, ...nativeProps }: ProseAnchorProps): import("react").JSX.Element;
+/**
+ * A subtree the family does not style. Every content rule carries a guard
+ * against this part and everything under it, and the four properties
+ * inheritance still carried in — family, size, leading and wrapping — are
+ * returned to control type here.
+ *
+ * Tailwind's `not-prose` and Typeset's `not-typeset` both leave the inherited
+ * type in place, so a card inside a large region is set in the region's text.
+ */
+export declare function ProseExclude({ render, ...nativeProps }: ProseExcludeProps): 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 GitHub Flavored Markdown emits at the end of a document. */
+export declare function ProseFootnotes({ render, ...nativeProps }: ProseFootnotesProps): 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=prose-parts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prose-parts.d.ts","sourceRoot":"","sources":["../../../src/prose/prose-parts.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EAEf,MAAM,eAAe,CAAC;AAEvB;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,cAAc,+VAInE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,gBAAgB,+BASjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,iBAAiB,+VAIzE;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,mBAAmB,+VAI7E"}

package/dist/types/prose/prose-scroll.d.ts

@@ -0,0 +1,27 @@
+import type { ProseScrollProps } from './prose.types';
+/**
+ * A wide block — a table, a fence — that scrolls sideways instead of pushing
+ * the page over. The axe rule `scrollable-region-focusable` makes that a WCAG
+ * 2.2 level A failure unless a keyboard can reach it, and anything that takes
+ * focus then needs a name and a role or it fails SC 4.1.2. Adrian Roselli's
+ * pattern is `<div role="region" aria-labelledby tabindex="0">`.
+ *
+ * None of the four surveyed implementations of this family ships it: Typeset's
+ * `typeset-scroll` is a `div` with `overflow: auto`, and GitHub's table
+ * wrapper is the same.
+ *
+ * The wiring is written **only while the block actually overflows**, measured
+ * by `@slotted/core/overflow` — the module `Tabs` already uses. A tab stop on
+ * a block that fits is a tab stop that does nothing, and a reader tabbing a
+ * documentation page would hit one per table.
+ *
+ * The name resolves in one order, so a renderer's component map can use the
+ * part with no arguments at all:
+ *
+ * 1. `labelledBy`, which is the block's own caption and is Roselli's answer;
+ * 2. a native `aria-label` this instance states;
+ * 3. `scroll` from the catalog of the language in force, with this instance's
+ *    `messages` laid over it.
+ */
+export declare function ProseScroll({ handleRef, labelledBy, messages, ref, render, ...nativeProps }: ProseScrollProps): 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=prose-scroll.d.ts.map

package/dist/types/prose/prose-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prose-scroll.d.ts","sourceRoot":"","sources":["../../../src/prose/prose-scroll.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAqB,gBAAgB,EAAwB,MAAM,eAAe,CAAC;AAE/F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CAAC,EAC1B,SAAS,EACT,UAAU,EACV,QAAQ,EACR,GAAG,EACH,MAAM,EACN,GAAG,WAAW,EACf,EAAE,gBAAgB,+VAoElB"}

package/dist/types/prose/prose.d.ts

@@ -0,0 +1,27 @@
+
+import type { ProseProps } from './prose.types';
+/**
+ * The typography of a region the application did not author element by
+ * element. The tree arrives from a Markdown renderer, a CMS or a language
+ * model, and the page never gets to put an attribute on the `h2`.
+ *
+ * Text the application does author is `Text` and `Heading`: those carry a
+ * size, a weight and a tone per element, and wrapping two authored paragraphs
+ * in this family is choosing a recipe over a decision. The boundary is who
+ * wrote the tags.
+ *
+ * It does not sanitise. The renderer that produced the tree is where a
+ * sanitiser belongs, and a component that both styled and sanitised would hide
+ * which of the two failed.
+ *
+ * The region paints no maximum width. `Container` owns measure, and one
+ * element composes it:
+ *
+ * ```tsx
+ * <Container size="measure">
+ *   <Prose>{rendered}</Prose>
+ * </Container>
+ * ```
+ */
+export declare function Prose({ flow, render, size, ...nativeProps }: ProseProps): 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=prose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prose.d.ts","sourceRoot":"","sources":["../../../src/prose/prose.tsx"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC;AAGzC,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,eAAe,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,KAAK,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,WAAW,EAAE,EAAE,UAAU,+VAYvE"}

package/dist/types/prose/prose.types.d.ts

@@ -0,0 +1,99 @@
+import type { PartialMessages, ProseMessages } from '@slotted/core/i18n';
+import type { ComponentPropsWithRef, HTMLAttributes, ReactNode, Ref, RefCallback } from 'react';
+/**
+ * The type-scale step the body text takes. Named for the scale's own steps, as
+ * `Text` names its own, so the offset from control type is visible rather than
+ * hidden: `lg` is one rem, and `--slotted-font-size-md` is the size a button
+ * label is set in.
+ */
+export type ProseSize = 'md' | 'lg' | 'xl';
+/**
+ * The space between blocks, from which every other distance in the region
+ * derives. `tight` is a message in a thread, `normal` a documentation page,
+ * `loose` an article.
+ */
+export type ProseFlow = 'tight' | 'normal' | 'loose';
+/** What an application sets once for every region under it. */
+export interface ProseDefaults {
+    flow: ProseFlow;
+    size: ProseSize;
+}
+export interface ProseDefaultsProviderProps extends Partial<ProseDefaults> {
+    children?: ReactNode | undefined;
+}
+/**
+ * What `render` receives on the region. It names the family's own attributes
+ * over the native ones every element shares; `ref` is not named because the
+ * element the consumer renders decides its own type.
+ */
+export interface ProseRootProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode | undefined;
+    'data-flow': ProseFlow;
+    'data-part': string;
+    'data-size': ProseSize;
+    'data-ui': string;
+}
+export interface ProseProps extends ComponentPropsWithRef<'div'> {
+    /** The space between blocks. Falls back to the injected default. */
+    flow?: ProseFlow | undefined;
+    /** Renders the wiring into another element — `article`, `section`, `main`. */
+    render?: ((props: ProseRootProps) => ReactNode) | undefined;
+    /** The type-scale step the body text takes. */
+    size?: ProseSize | undefined;
+}
+export interface ProsePartProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode | undefined;
+    'data-part': string;
+}
+export interface ProseLeadProps extends ComponentPropsWithRef<'p'> {
+    render?: ((props: ProsePartProps) => ReactNode) | undefined;
+}
+export interface ProseAnchorProps extends ComponentPropsWithRef<'a'> {
+    render?: ((props: ProsePartProps) => ReactNode) | undefined;
+}
+export interface ProseExcludeProps extends ComponentPropsWithRef<'div'> {
+    render?: ((props: ProsePartProps) => ReactNode) | undefined;
+}
+export interface ProseFootnotesProps extends ComponentPropsWithRef<'section'> {
+    render?: ((props: ProsePartProps) => ReactNode) | undefined;
+}
+/** What `ProseScroll` writes on its element once it knows whether it scrolls. */
+export interface ProseScrollRootProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode | undefined;
+    'data-part': string;
+    /**
+     * Named here, unlike every other part's render props, because this one part
+     * has to be measured: a consumer who substitutes the element still hands the
+     * family the node whose width decides whether the wiring appears at all.
+     */
+    ref: RefCallback<HTMLElement>;
+}
+export interface ProseScrollProps extends Omit<ComponentPropsWithRef<'div'>, 'ref'> {
+    /**
+     * Words laid over the catalog of the language in force: the last resort name
+     * of the region (`scroll`). A native `aria-label` still wins.
+     */
+    messages?: PartialMessages<ProseMessages> | undefined;
+    /** Names it from an element already on the page — a table's own caption. */
+    labelledBy?: string | undefined;
+    /** The handle a consumer needs when content arrives outside React's cycle. */
+    handleRef?: ProseScrollHandleRef | undefined;
+    ref?: Ref<HTMLElement> | undefined;
+    render?: ((props: ProseScrollRootProps) => ReactNode) | undefined;
+}
+/**
+ * The one thing a consumer cannot express declaratively: content that arrived
+ * without React knowing — a renderer writing into the DOM, a font landing, an
+ * image finishing — changes whether the block overflows, and the observer has
+ * already measured.
+ */
+export interface ProseScrollHandle {
+    /** Measures the block again and rewrites the wiring if the answer changed. */
+    refresh: () => void;
+    /** Whether the block is scrollable as of the last measurement. */
+    overflowing: () => boolean;
+}
+export type ProseScrollHandleRef = ((handle: ProseScrollHandle | null) => void) | {
+    current: ProseScrollHandle | null;
+};
+//# sourceMappingURL=prose.types.d.ts.map

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

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

package/dist/types/radio-group/index.d.ts

@@ -0,0 +1,5 @@
+export { RadioGroup, useRadioGroup } from './radio-group';
+export { RadioGroupDefaultsProvider, useRadioGroupDefaults } from './radio-group-defaults';
+export { Radio } from './radio-group-parts';
+export type { RadioGroupContextValue, RadioGroupDefaults, RadioGroupDefaultsProviderProps, RadioGroupLabelPlacement, RadioGroupOrientation, RadioGroupProps, RadioGroupRootProps, RadioGroupSelectionReason, RadioGroupSize, RadioGroupVariant, RadioProps, RadioRootProps, } from './radio-group.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/radio-group/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/radio-group/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC3F,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,YAAY,EACV,sBAAsB,EACtB,kBAAkB,EAClB,+BAA+B,EAC/B,wBAAwB,EACxB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,EACnB,yBAAyB,EACzB,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,cAAc,GACf,MAAM,qBAAqB,CAAC"}

package/dist/types/radio-group/radio-group-defaults.d.ts

@@ -0,0 +1,11 @@
+import type { RadioGroupDefaults, RadioGroupDefaultsProviderProps } from './radio-group.types';
+/** What a radio group renders as here, before it states anything of its own. */
+export declare function useRadioGroupDefaults(): RadioGroupDefaults;
+/**
+ * An application decides once how its sets of choices flow, rather than
+ * repeating the same props on every group in a form. A group that states any of
+ * them itself still wins, and a field around it outranks this provider for
+ * `size`.
+ */
+export declare function RadioGroupDefaultsProvider({ children, ...defaults }: RadioGroupDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=radio-group-defaults.d.ts.map

package/dist/types/radio-group/radio-group-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group-defaults.d.ts","sourceRoot":"","sources":["../../../src/radio-group/radio-group-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,+BAA+B,EAAE,MAAM,qBAAqB,CAAC;AAW/F,gFAAgF;AAChF,wBAAgB,qBAAqB,IAAI,kBAAkB,CAE1D;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,EACzC,QAAQ,EACR,GAAG,QAAQ,EACZ,EAAE,+BAA+B,+BAejC"}

package/dist/types/radio-group/radio-group-parts.d.ts

@@ -0,0 +1,15 @@
+import type { RadioProps } from './radio-group.types';
+/**
+ * One item of the set.
+ *
+ * It is a part of `radio-group` and not a family: outside a group it has no
+ * exclusive set to belong to, and the platform's whole keyboard model is
+ * defined over the set.
+ *
+ * The mark is a sibling of the control for the reason `checkbox` records —
+ * Firefox renders no pseudo-element on an `input` — and the label names the
+ * control through `for` so the description below it can be read without
+ * choosing anything.
+ */
+export declare function Radio({ 'aria-describedby': describedBy, children, className, description, disabled, id, onChange, onClick, ref, render, style, value, ...nativeProps }: RadioProps): 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=radio-group-parts.d.ts.map

package/dist/types/radio-group/radio-group-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group-parts.d.ts","sourceRoot":"","sources":["../../../src/radio-group/radio-group-parts.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAA6B,UAAU,EAAkB,MAAM,qBAAqB,CAAC;AAWjG;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,EACpB,kBAAkB,EAAE,WAAW,EAC/B,QAAQ,EACR,SAAS,EACT,WAAW,EACX,QAAQ,EACR,EAAE,EACF,QAAQ,EACR,OAAO,EACP,GAAG,EACH,MAAM,EACN,KAAK,EACL,KAAK,EACL,GAAG,WAAW,EACf,EAAE,UAAU,+VA+DZ"}

package/dist/types/radio-group/radio-group.d.ts

@@ -0,0 +1,29 @@
+
+import type { RadioGroupContextValue, RadioGroupProps } from './radio-group.types';
+/**
+ * What the group around this item says. A `Radio` outside a group has no
+ * exclusive set to belong to and no name to be grouped by, so this throws
+ * rather than rendering a control that looks right and behaves like nothing.
+ */
+export declare function useRadioGroup(): RadioGroupContextValue;
+/**
+ * One choice out of a set.
+ *
+ * **The keyboard is the platform's, and that is why the items share a `name`.**
+ * Native radios in one form owner with one name already implement the APG's
+ * whole table: Tab lands on the checked item or on the first, `Space` checks,
+ * both arrow axes move focus and selection together, the set wraps, and
+ * disabled items are skipped — in a right-to-left document too. A roving
+ * `tabindex` written once per binding would reimplement all of it twice.
+ *
+ * **The role is conditional, and the condition is the field group.** A
+ * `field-group` is a `fieldset` with a `legend`, which is already a named group;
+ * a `radiogroup` inside it, named by the same legend, is the same group
+ * announced twice. A consumer's explicit `role` wins over both.
+ *
+ * **`readOnly` is enforced, because the platform has none.** A radio ignores
+ * `readonly`, so the group refuses the change on the item's own `click` — the
+ * one event a pointer and `Space` share — and announces `aria-readonly`.
+ */
+export declare function RadioGroup({ 'aria-describedby': describedBy, 'aria-invalid': ariaInvalid, 'aria-label': ariaLabel, 'aria-labelledby': labelledBy, 'aria-readonly': ariaReadOnly, 'aria-orientation': ariaOrientation, 'aria-required': ariaRequired, children, className, defaultValue, disabled, invalid, labelPlacement, variant, name, onValueChange, orientation, readOnly, ref, render, required, role, size, style, value, ...nativeProps }: RadioGroupProps): import("react").JSX.Element;
+//# sourceMappingURL=radio-group.d.ts.map

package/dist/types/radio-group/radio-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group.d.ts","sourceRoot":"","sources":["../../../src/radio-group/radio-group.tsx"],"names":[],"mappings":"AAAA,OAAO,6CAA6C,CAAC;AAQrD,OAAO,KAAK,EACV,sBAAsB,EACtB,eAAe,EAGhB,MAAM,qBAAqB,CAAC;AAI7B;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,sBAAsB,CAMtD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,EACzB,kBAAkB,EAAE,WAAW,EAC/B,cAAc,EAAE,WAAW,EAC3B,YAAY,EAAE,SAAS,EACvB,iBAAiB,EAAE,UAAU,EAC7B,eAAe,EAAE,YAAY,EAC7B,kBAAkB,EAAE,eAAe,EACnC,eAAe,EAAE,YAAY,EAC7B,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,cAAc,EACd,OAAO,EACP,IAAI,EACJ,aAAa,EACb,WAAW,EACX,QAAQ,EACR,GAAG,EACH,MAAM,EACN,QAAQ,EACR,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,KAAK,EACL,GAAG,WAAW,EACf,EAAE,eAAe,+BA4FjB"}

package/dist/types/radio-group/radio-group.types.d.ts

@@ -0,0 +1,128 @@
+import type { ChangeRequest } from '@slotted/core/state';
+import type { ComponentPropsWithRef, HTMLAttributes, ReactNode } from 'react';
+/** The type step the group and every item inside it sit at. */
+export type RadioGroupSize = 'sm' | 'md' | 'lg';
+/** How the choices flow. `horizontal` wraps; a set of options is not a scroll region. */
+export type RadioGroupOrientation = 'vertical' | 'horizontal';
+/**
+ * Whether the choice is a box beside a line of text or a framed surface whose
+ * whole area is the target. `tile` is the name Carbon and Cloudscape give the
+ * framed choice; Mantine and Chakra call it a card, which is a family here.
+ */
+export type RadioGroupVariant = 'plain' | 'tile';
+/**
+ * Which side of its own label the circle is on. It is never inherited from a
+ * `field`: that family's `labelPlacement` answers where a field's label sits
+ * relative to its control, and a radio's label is its own.
+ */
+export type RadioGroupLabelPlacement = 'end' | 'start';
+/** Why the value moved. A radio group can produce exactly these two. */
+export type RadioGroupSelectionReason = Extract<ChangeRequest<string>['reason'], 'pointer' | 'keyboard'>;
+/**
+ * The request a radio group emits. Its `previous` is `undefined` while nothing
+ * has been chosen, which is the state the APG asks a group to start in, and a
+ * request typed over `string` alone could not say so. Its `value` is always a
+ * string: a radio cannot be unchosen by choosing it again.
+ */
+export type RadioGroupChangeRequest = ChangeRequest<string | undefined>;
+/** What an application sets once for every radio group under it. */
+export interface RadioGroupDefaults {
+    labelPlacement: RadioGroupLabelPlacement;
+    variant: RadioGroupVariant;
+    orientation: RadioGroupOrientation;
+    size: RadioGroupSize;
+}
+export interface RadioGroupDefaultsProviderProps extends Partial<RadioGroupDefaults> {
+    children?: ReactNode | undefined;
+}
+/** What the group hands every item inside it. */
+export interface RadioGroupContextValue {
+    disabled: boolean | undefined;
+    invalid: boolean | undefined;
+    labelPlacement: RadioGroupLabelPlacement;
+    variant: RadioGroupVariant;
+    /**
+     * The submission name every item shares, and the reason the platform treats
+     * the set as one group. It is generated when the consumer writes none.
+     */
+    name: string;
+    readOnly: boolean | undefined;
+    required: boolean | undefined;
+    select: (value: string, reason: RadioGroupSelectionReason, source: unknown) => boolean;
+    size: RadioGroupSize;
+    value: string | undefined;
+}
+/** What `render` receives for the group's root. */
+export interface RadioGroupRootProps extends HTMLAttributes<HTMLElement> {
+    'data-disabled'?: '' | undefined;
+    'data-invalid'?: '' | undefined;
+    'data-label-placement': RadioGroupLabelPlacement;
+    'data-orientation': RadioGroupOrientation;
+    'data-part': string;
+    'data-readonly'?: '' | undefined;
+    'data-size': RadioGroupSize;
+    'data-ui': string;
+    'data-variant': RadioGroupVariant;
+}
+/** What `render` receives for one item. */
+export interface RadioRootProps extends HTMLAttributes<HTMLElement> {
+    'data-checked'?: '' | undefined;
+    'data-disabled'?: '' | undefined;
+    'data-part': string;
+}
+export interface RadioGroupProps extends Omit<ComponentPropsWithRef<'div'>, 'defaultValue'> {
+    /** The value an uncontrolled group starts from, read once. */
+    defaultValue?: string | undefined;
+    /**
+     * Unstated rather than `false`, so the group defers to the field around it.
+     * Stated, it wins, and it reaches every item as the native attribute.
+     */
+    disabled?: boolean | undefined;
+    /** Unstated rather than `false`. Writes `aria-invalid` and `data-invalid`. */
+    invalid?: boolean | undefined;
+    /** Defaults to the provider, then to `end`. Reaches every item. */
+    labelPlacement?: RadioGroupLabelPlacement | undefined;
+    /** Defaults to the provider, then to `plain`. Handed to every choice. */
+    variant?: RadioGroupVariant | undefined;
+    /**
+     * The submission name the set shares. Generated when it is not written,
+     * because grouping is by name within the form owner and an unnamed set is not
+     * a set — the price is that an unnamed group inside a form submits under a
+     * generated key.
+     */
+    name?: string | undefined;
+    /** Called before the value moves, with the request that carries the reason. */
+    onValueChange?: ((value: string, request: RadioGroupChangeRequest) => void) | undefined;
+    /** Defaults to the provider, then to `vertical`. */
+    orientation?: RadioGroupOrientation | undefined;
+    /**
+     * Unstated rather than `false`. Every item keeps its tab stop and its
+     * contrast, the group announces `aria-readonly`, and every change is refused.
+     */
+    readOnly?: boolean | undefined;
+    /** Renders the group's root into another element. */
+    render?: ((props: RadioGroupRootProps) => ReactNode) | undefined;
+    /** Unstated rather than `false`. Writes `aria-required` on the group. */
+    required?: boolean | undefined;
+    /** Defaults to the field, then to the provider, then to `md`. */
+    size?: RadioGroupSize | undefined;
+    /** Present means controlled, for the life of the component. */
+    value?: string | undefined;
+}
+export interface RadioProps extends Omit<ComponentPropsWithRef<'input'>, 'children' | 'size' | 'type'> {
+    /** The label. It is the control's accessible name, through `for`. */
+    children?: ReactNode | undefined;
+    /** Help text below the label, wired with `aria-describedby`. */
+    description?: ReactNode | undefined;
+    /**
+     * Unstated rather than `false`, so the item defers to the group. Stated, it
+     * wins, and it is the native attribute — which is what makes the browser skip
+     * the item with the arrow keys.
+     */
+    disabled?: boolean | undefined;
+    /** Renders the item's root into another element. */
+    render?: ((props: RadioRootProps) => ReactNode) | undefined;
+    /** The value this item selects. It is what the group's value holds. */
+    value: string;
+}
+//# sourceMappingURL=radio-group.types.d.ts.map

package/dist/types/radio-group/radio-group.types.d.ts.map

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

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

@@ -0,0 +1,6 @@
+export { Rating } from './rating';
+export { RatingProvider, useRatingDefaults } from './rating-defaults';
+export { RatingDisplay } from './rating-display';
+export { RatingSummary } from './rating-summary';
+export type { RatingCaptionState, RatingChangeReason, RatingChangeRequest, RatingDefaults, RatingDisplayProps, RatingDisplayVariant, RatingHandle, RatingInsight, RatingInsightThresholds, RatingLevelsChangeRequest, RatingProps, RatingProviderProps, RatingRootProps, RatingSize, RatingStep, RatingSummaryProps, RatingSummaryVariant, RatingSymbolState, RatingTone, } from './rating.types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rating/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,aAAa,EACb,uBAAuB,EACvB,yBAAyB,EACzB,WAAW,EACX,mBAAmB,EACnB,eAAe,EACf,UAAU,EACV,UAAU,EACV,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,EACjB,UAAU,GACX,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { RatingDefaults, RatingProviderProps } from './rating.types';
+/** What a rating renders as here, before it states anything of its own. */
+export declare function useRatingDefaults(): RatingDefaults;
+/**
+ * An application decides once the step, the tone, the scale, whether a press
+ * on the checked symbol clears it and the insight thresholds. An instance that
+ * states any of them still wins; `insightThresholds` merges key by key. The
+ * words and the locale come from the language in force (`SlottedProvider`).
+ */
+export declare function RatingProvider({ children, ...defaults }: RatingProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=rating-defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rating-defaults.d.ts","sourceRoot":"","sources":["../../../src/rating/rating-defaults.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAY1E,2EAA2E;AAC3E,wBAAgB,iBAAiB,IAAI,cAAc,CAElD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,mBAAmB,+BAgB5E"}

package/dist/types/rating/rating-display.d.ts

@@ -0,0 +1,30 @@
+
+import type { ReactNode } from 'react';
+import type { RatingDisplayProps, RatingSymbolState } from './rating.types';
+/** A share written into a custom property, to four places as the harness writes it. */
+export declare function shareValue(share: number): string;
+/** The star every symbol draws unless `renderSymbol` replaces it. */
+export declare function RatingStar(): import("react").JSX.Element;
+/**
+ * The two layers of one symbol: the unlit shape, and the same shape clipped to
+ * the lit share by the stylesheet. A replacement symbol is drawn in both, so it
+ * lights the way the star does.
+ */
+export declare function RatingSymbolLayers({ fill, index, renderSymbol, }: RatingSymbolState & {
+    renderSymbol: ((state: RatingSymbolState) => ReactNode) | undefined;
+}): import("react").JSX.Element;
+/**
+ * A rating the page reports rather than one the reader gives.
+ *
+ * It is one image with one name: the symbols, the number and the count are
+ * hidden from assistive technology, and `aria-label` says all three once.
+ * Each symbol is lit by its own fraction through `--slotted-rating-fill`, so a
+ * display draws any value — 4.6 lights six tenths of the fifth star — where
+ * the input member offers whole and half steps.
+ *
+ * `compact` and `histogram` draw one star beside the number, for a row that
+ * has no room for five; `histogram` adds one bar per level, each the share of
+ * the largest, so the shape of a distribution reads at list density.
+ */
+export declare function RatingDisplay({ 'aria-label': ariaLabel, className, count, distribution, locale, max, messages, ref, render, renderSymbol, role, showValue, size, style, tone, value, variant, ...nativeProps }: RatingDisplayProps): 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=rating-display.d.ts.map

package/dist/types/rating/rating-display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rating-display.d.ts","sourceRoot":"","sources":["../../../src/rating/rating-display.tsx"],"names":[],"mappings":"AAAA,OAAO,mCAAmC,CAAC;AAI3C,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAC;AAKtD,OAAO,KAAK,EAAE,kBAAkB,EAAmB,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE7F,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,qEAAqE;AACrE,wBAAgB,UAAU,gCAMzB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EACJ,KAAK,EACL,YAAY,GACb,EAAE,iBAAiB,GAAG;IACrB,YAAY,EAAE,CAAC,CAAC,KAAK,EAAE,iBAAiB,KAAK,SAAS,CAAC,GAAG,SAAS,CAAC;CACrE,+BAQA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,EAC5B,YAAY,EAAE,SAAS,EACvB,SAAS,EACT,KAAK,EACL,YAAY,EACZ,MAAM,EACN,GAAG,EACH,QAAQ,EACR,GAAG,EACH,MAAM,EACN,YAAY,EACZ,IAAI,EACJ,SAAS,EACT,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,KAAK,EACL,OAAO,EACP,GAAG,WAAW,EACf,EAAE,kBAAkB,+TA6EpB"}

package/dist/types/rating/rating-summary.d.ts

@@ -0,0 +1,20 @@
+
+import type { ReactNode } from 'react';
+import type { RatingSummaryProps } from './rating.types';
+/**
+ * The aggregate of many ratings.
+ *
+ * `bars` is the summary a product page leads with: the mean as a figure, the
+ * scale beside it, the stars that draw it and the count, then one bar per
+ * level, highest first, each the level's share of the total. `spectrum` reads
+ * the same counts as a histogram on the axis of the scale, lowest first, with
+ * the mean, its 95% interval and the one conclusion `summariseRatings` draws:
+ * divided, too few, a consensus, or mixed.
+ *
+ * With `filterable`, each level is a `button` with `aria-pressed`, disabled
+ * where nobody rated, and the pressed levels are a state model of their own.
+ * With nothing rated, the aggregate writes no figure and no scale: an absent
+ * mean is not a nought.
+ */
+export declare function RatingSummary({ className, counts, defaultSelectedLevels, filterable, insightThresholds, locale, max, messages, onSelectedLevelsChange, ref, render, selectedLevels, showInsight, size, style, tone, variant, ...nativeProps }: RatingSummaryProps): 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=rating-summary.d.ts.map

package/dist/types/rating/rating-summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rating-summary.d.ts","sourceRoot":"","sources":["../../../src/rating/rating-summary.tsx"],"names":[],"mappings":"AAAA,OAAO,mCAAmC,CAAC;AAO3C,OAAO,KAAK,EAA6B,SAAS,EAAE,MAAM,OAAO,CAAC;AAKlE,OAAO,KAAK,EAAmB,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AA4B1E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,EAC5B,SAAS,EACT,MAAM,EACN,qBAAqB,EACrB,UAAU,EACV,iBAAiB,EACjB,MAAM,EACN,GAAG,EACH,QAAQ,EACR,sBAAsB,EACtB,GAAG,EACH,MAAM,EACN,cAAc,EACd,WAAW,EACX,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,OAAO,EACP,GAAG,WAAW,EACf,EAAE,kBAAkB,+TAmOpB"}

package/dist/types/rating/rating.d.ts

@@ -0,0 +1,29 @@
+
+import type { RatingProps } from './rating.types';
+/**
+ * An ordinal value chosen by lighting symbols in order.
+ *
+ * **Every value is a native radio.** The radios share a name, so `Tab`, `Space`,
+ * form submission and a reset are the platform's; the family adds only what the
+ * platform lacks. The arrows stop at both ends instead of wrapping, `Home` and
+ * `End` reach them, and `Backspace` and `Delete` empty the value — all asked of
+ * `ratingForKey`, so both bindings answer every key the same way.
+ *
+ * **The lit share is CSS.** The fill follows `:checked` and `:hover` on the
+ * radios, so the component writes no fill of its own and a preview costs no
+ * render.
+ *
+ * **A press on the checked radio empties the value** while `clearable` holds,
+ * because a radio cannot be unchosen by choosing it and a rating the reader
+ * gave by mistake needs a way back to none.
+ *
+ * **A finger or a pen scrubs.** Dragged along the row, it asks for the value
+ * `ratingAtPoint` reads under it, and only when that value changes. A mouse
+ * does not, because it already has hover to preview and a press to choose.
+ *
+ * **`readOnly` is enforced, because the platform has none.** The change is
+ * refused on the radio's own `click`, the one event a pointer and `Space`
+ * share, and the group announces `aria-readonly`.
+ */
+export declare function Rating({ 'aria-describedby': describedBy, 'aria-invalid': ariaInvalid, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, 'aria-readonly': ariaReadOnly, 'aria-required': ariaRequired, caption, className, clearable, defaultValue, disabled, form, handle, invalid, locale, max, messages, name, onKeyDown, onPointerDown, onPointerLeave, onPointerOver, onPreviewChange, onValueChange, readOnly, ref, render, renderSymbol, required, role, size, step, style, tone, value, ...nativeProps }: RatingProps): 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=rating.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rating.d.ts","sourceRoot":"","sources":["../../../src/rating/rating.tsx"],"names":[],"mappings":"AAAA,OAAO,mCAAmC,CAAC;AAkB3C,OAAO,KAAK,EAAsB,WAAW,EAAmB,MAAM,gBAAgB,CAAC;AAiBvF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,MAAM,CAAC,EACrB,kBAAkB,EAAE,WAAW,EAC/B,cAAc,EAAE,WAAW,EAC3B,YAAY,EAAE,SAAS,EACvB,iBAAiB,EAAE,cAAc,EACjC,eAAe,EAAE,YAAY,EAC7B,eAAe,EAAE,YAAY,EAC7B,OAAO,EACP,SAAS,EACT,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,OAAO,EACP,MAAM,EACN,GAAG,EACH,QAAQ,EACR,IAAI,EACJ,SAAS,EACT,aAAa,EACb,cAAc,EACd,aAAa,EACb,eAAe,EACf,aAAa,EACb,QAAQ,EACR,GAAG,EACH,MAAM,EACN,YAAY,EACZ,QAAQ,EACR,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,KAAK,EACL,GAAG,WAAW,EACf,EAAE,WAAW,+VAsPb"}