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

package/dist/types/tag/tag-chip.d.ts

@@ -0,0 +1,120 @@
+
+import type { KeyboardEvent, ReactNode, SyntheticEvent } from 'react';
+import type { TagAppearanceProps, TagRemovableProps, TagRemoveReason, TagRootPassthrough, TagRootProps, TagShape, TagSize, TagTone, TagVariant } from './tag.types';
+/**
+ * Every control a group's keyboard moves between, in the order the DOM holds
+ * them: a chip's own control, then its remove control, then the next chip's.
+ * Read literally from the APG Toolbar pattern, which needs no second axis to
+ * reach a control inside an item.
+ */
+export declare const TAG_CONTROL_SELECTOR = "[data-part=\"body\"]:is(a, button), [data-part=\"remove\"]";
+export declare function TagItemRoleProvider({ children, role, }: {
+    children: ReactNode;
+    role: string | undefined;
+}): import("react").JSX.Element;
+export declare function useTagItemRole(): string | undefined;
+export interface ResolvedAppearance {
+    shape: TagShape;
+    size: TagSize;
+    tone: TagTone;
+    variant: TagVariant;
+}
+/**
+ * An explicit prop wins over the provider, and the provider over the family's
+ * own default. The three are read in that order rather than merged.
+ */
+export declare function useAppearance(props: TagAppearanceProps): ResolvedAppearance;
+/**
+ * The public identity of the chip box: one family identifier, one root part,
+ * the axes a consumer may select on, and the two states that are attributes.
+ * Class names and the shape of the tree below this element are not contract.
+ */
+export declare function rootData(appearance: ResolvedAppearance, state: {
+    disabled?: boolean | undefined;
+    selected?: boolean | undefined;
+}): {
+    readonly 'data-ui': "tag";
+    readonly 'data-part': "root";
+    readonly 'data-tone': TagTone;
+    readonly 'data-variant': TagVariant;
+    readonly 'data-size': TagSize;
+    readonly 'data-shape': TagShape;
+    readonly 'data-disabled': "" | undefined;
+    readonly 'data-selected': "" | undefined;
+};
+export interface Removal {
+    /** Whether the chip renders a remove control at all. */
+    removable: boolean;
+    /** The control's own disabled state, which the chip's own also forces. */
+    removeDisabled: boolean;
+    /** The word announced before the tag's own label, in the language in force. */
+    removeLabel: string;
+    request: (reason: TagRemoveReason, source: SyntheticEvent) => void;
+}
+export declare function useRemoval(props: TagRemovableProps & {
+    disabled?: boolean;
+}): Removal;
+/**
+ * `Backspace` and `Delete` on a removable chip, which is the shortcut MUI,
+ * Primer, React Aria and Angular Material all ship — Primer goes as far as
+ * announcing it in a visually hidden sentence beside the value.
+ *
+ * It is bound to the chip box rather than to either control, so it answers
+ * wherever focus is inside the chip, and a consumer's own handler on the
+ * control runs first and can refuse it by stopping propagation.
+ *
+ * A held key repeats, and a repeat would remove the chip that focus has just
+ * landed on. The default is prevented because `Backspace` still navigates back
+ * in some browsers when nothing is being edited.
+ */
+export declare function removalKeydown(removal: Removal): (event: KeyboardEvent<HTMLElement>) => void;
+interface TagContentOptions {
+    children?: ReactNode | undefined;
+    end?: ReactNode | undefined;
+    /** The selection mark, on the one member that holds a selection. */
+    indicator?: ReactNode | undefined;
+    labelId: string;
+    start?: ReactNode | undefined;
+}
+/**
+ * What goes inside the body, in reading order. The words get a box of their
+ * own — it is what `text-box` needs to trim the line to the cap and the
+ * baseline, what `text-overflow` needs to clip a long value, and what
+ * `aria-labelledby` on the remove control points at so it announces the value
+ * rather than the word "Remove" on its own.
+ */
+export declare function TagContent({ children, end, indicator, labelId, start }: TagContentOptions): import("react").JSX.Element;
+interface TagRemoveOptions {
+    labelId: string;
+    removal: Removal;
+    wordId: string;
+}
+/**
+ * The control at the end of the chip. Its name is composed rather than
+ * repeated: the hidden word and the tag's own label are joined by
+ * `aria-labelledby`, so it announces "Remove Design" without the consumer
+ * writing the value a second time — the string four of the surveyed
+ * implementations make the consumer keep in step with the value by hand.
+ *
+ * Text referenced by `aria-labelledby` counts even when the element holding it
+ * is hidden, which is what lets the word cost no space.
+ */
+export declare function TagRemove({ labelId, removal, wordId }: TagRemoveOptions): import("react").JSX.Element;
+interface TagFrameOptions {
+    appearance: ResolvedAppearance;
+    /** The body and, when there is one, the remove control. */
+    children: ReactNode;
+    disabled?: boolean | undefined;
+    removal: Removal;
+    render?: ((props: TagRootProps) => ReactNode) | undefined;
+    rootProps?: TagRootPassthrough | undefined;
+    selected?: boolean | undefined;
+}
+/**
+ * The chip box. It is never the interactive element: a `button` cannot contain
+ * a `button` and an `a` cannot contain either, so a chip that both acts and
+ * removes has to put its two controls side by side.
+ */
+export declare function TagFrame({ appearance, children, disabled, removal, render, rootProps, selected, }: TagFrameOptions): 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;
+export {};
+//# sourceMappingURL=tag-chip.d.ts.map

package/dist/types/tag/tag-chip.d.ts.map

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

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

@@ -0,0 +1,15 @@
+import type { TagDefaults, TagDefaultsProviderProps } from './tag.types';
+/** What a tag renders as here, before it states anything of its own. */
+export declare function useTagDefaults(): TagDefaults;
+/**
+ * An application decides once how its tags are painted and how large they
+ * are, rather than repeating four props on every chip in a filter bar. A tag
+ * that states any of them itself still wins: an explicit prop is never
+ * overridden by context. The remove control's word comes from the language in
+ * force (`SlottedProvider`).
+ *
+ * Ant Design's `ConfigProvider` is the only surveyed implementation with an
+ * equivalent, and it ships one binding.
+ */
+export declare function TagDefaultsProvider({ children, ...defaults }: TagDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=tag-defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag-defaults.d.ts","sourceRoot":"","sources":["../../../src/tag/tag-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAWzE,wEAAwE;AACxE,wBAAgB,cAAc,IAAI,WAAW,CAE5C;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,wBAAwB,+BAetF"}

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

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+/**
+ * One band of the overview page: the heading and its sentence in the sidebar
+ * column, the demonstration in the wide one.
+ *
+ * The section is what carries the page's inset and the gap between its two
+ * columns; the intro is only the column. An overview that put its headings and
+ * its demonstrations straight into the intro — which is what this page did
+ * before a reviewer read it — inherits neither, so every chip sits against the
+ * panel's own edge and the bands run into each other.
+ */
+export declare function LabSection({ children, columns, description, title, }: {
+    children: ReactNode;
+    columns?: 1 | 2 | 3;
+    description: string;
+    title: string;
+}): import("react").JSX.Element;
+/**
+ * What the four reference pages share: a scene frame, and a demonstration list
+ * that behaves like a real one. Written once here rather than four times,
+ * because a removal that does not actually remove anything demonstrates
+ * nothing — the pages exercise the family instead of posing it.
+ */
+export declare function DemoScene({ children, label, note, }: {
+    children: ReactNode;
+    label: string;
+    note: string;
+}): import("react").JSX.Element;
+/** The artwork belongs to the consumer, and it is Lucide's; a character is never an icon. */
+export declare const GLYPH_TAG: import("react").JSX.Element;
+export declare const GLYPH_CHEVRON: import("react").JSX.Element;
+//# sourceMappingURL=tag-demo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag-demo.d.ts","sourceRoot":"","sources":["../../../src/tag/tag-demo.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,OAAO,EACP,WAAW,EACX,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,SAAS,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,+BAmBA;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,EACxB,QAAQ,EACR,KAAK,EACL,IAAI,GACL,EAAE;IACD,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,+BAUA;AAED,6FAA6F;AAC7F,eAAO,MAAM,SAAS,6BAA+C,CAAC;AACtE,eAAO,MAAM,aAAa,6BAAuD,CAAC"}

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

@@ -0,0 +1,22 @@
+import type { TagGroupProps } from './tag.types';
+/**
+ * The run of tags, and the keyboard that belongs to it.
+ *
+ * It is a toolbar: the APG pattern for "a container for grouping a set of
+ * controls, such as buttons". One tab stop, arrow keys between the controls
+ * inside it, `Home` and `End` at the ends. React Aria and Angular Material
+ * reach for the Grid pattern instead, which buys a second axis — "the next
+ * chip" apart from "the next control in this chip" — at the price of two
+ * wrapper elements per chip and a `gridcell` role over every button. A single
+ * wrapping run does not need the second axis.
+ *
+ * The roving order is every control in DOM order: a chip's body, then its
+ * remove control, then the next chip's. That is what makes the X reachable
+ * without a second dimension.
+ *
+ * Writing `role="list"` turns the keyboard off. A list is a structure rather
+ * than a widget, its items are not controls to move between, and a screen
+ * reader announces its length — which a toolbar does not.
+ */
+export declare function TagGroup({ children, loop, orientation, ref, render, role, ...nativeProps }: TagGroupProps): 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=tag-group.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag-group.d.ts","sourceRoot":"","sources":["../../../src/tag/tag-group.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAqB,MAAM,aAAa,CAAC;AAEpE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,EACvB,QAAQ,EACR,IAAW,EACX,WAA0B,EAC1B,GAAG,EACH,MAAM,EACN,IAAgB,EAChB,GAAG,WAAW,EACf,EAAE,aAAa,+VAgEf"}

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

@@ -0,0 +1,16 @@
+import type { TagLinkProps } from './tag.types';
+/**
+ * A chip that navigates — Ant's `href`, Primer's `Token` with a destination,
+ * PatternFly's link label. It is a real `<a>`, so the platform's own middle
+ * click, context menu, download and "open in new tab" all keep working, and a
+ * router substitutes its own component through `render`.
+ *
+ * `disabled` is not an attribute an anchor has. A chip that cannot be followed
+ * loses its `href`, announces `aria-disabled`, and keeps its place in the tab
+ * sequence — the line `link` draws for the same case: without an `href` the
+ * anchor would drop out of that sequence and take its own explanation with it,
+ * so the zero is stated rather than inherited. The activation is refused in
+ * the capture phase, before any listener the consumer attached can run.
+ */
+export declare function TagLink({ children, disabled, end, href, onAuxClickCapture, onClickCapture, onKeyDownCapture, onRemove, removeDisabled, messages, render, rootProps, shape, size, start, tabIndex, tone, variant, ...nativeProps }: TagLinkProps): import("react").JSX.Element;
+//# sourceMappingURL=tag-link.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag-link.d.ts","sourceRoot":"","sources":["../../../src/tag/tag-link.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAoB,YAAY,EAAE,MAAM,aAAa,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,EACtB,QAAQ,EACR,QAAgB,EAChB,GAAG,EACH,IAAI,EACJ,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,QAAQ,EACR,cAAsB,EACtB,QAAQ,EACR,MAAM,EACN,SAAS,EACT,KAAK,EACL,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,GAAG,WAAW,EACf,EAAE,YAAY,+BAgDd"}

package/dist/types/tag/tag-toggle.d.ts

@@ -0,0 +1,20 @@
+import type { TagToggleProps } from './tag.types';
+/**
+ * A chip that holds a selection: a filter that is on, a facet that is chosen.
+ * Carbon calls it a selectable tag, Ant a checkable tag, Fluent a selected
+ * tag, React Aria a selected item in a tag group — and none of the four ships
+ * the uncontrolled half, so a filter bar cannot be written without a `useState`
+ * for every chip in it.
+ *
+ * It announces `aria-pressed` rather than `aria-selected`, which is a
+ * deliberate departure with a cost: `aria-selected` is only valid inside a
+ * `listbox`, a `grid` or a `tree`, and an `option` may not contain the remove
+ * control this family puts beside the label. The family keeps `selected` as
+ * its own word, because that is what the field calls it, and writes
+ * `data-selected` for styling.
+ *
+ * The label never changes with the state — the APG's rule for a toggle — so
+ * "Open" stays "Open" and the state is announced beside it.
+ */
+export declare function TagToggle({ children, defaultSelected, disabled, end, onClick, onRemove, onSelectedChange, removeDisabled, messages, render, rootProps, selected, shape, size, start, tone, type, variant, ...nativeProps }: TagToggleProps): import("react").JSX.Element;
+//# sourceMappingURL=tag-toggle.d.ts.map

package/dist/types/tag/tag-toggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-toggle.d.ts","sourceRoot":"","sources":["../../../src/tag/tag-toggle.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAsB,cAAc,EAAE,MAAM,aAAa,CAAC;AAatE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,EACxB,QAAQ,EACR,eAAe,EACf,QAAgB,EAChB,GAAG,EACH,OAAO,EACP,QAAQ,EACR,gBAAgB,EAChB,cAAsB,EACtB,QAAQ,EACR,MAAM,EACN,SAAS,EACT,QAAQ,EACR,KAAK,EACL,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,IAAe,EACf,OAAO,EACP,GAAG,WAAW,EACf,EAAE,cAAc,+BAiEhB"}

package/dist/types/tag/tag.d.ts

@@ -0,0 +1,17 @@
+import type { TagProps } from './tag.types';
+/**
+ * An entity, a filter or a compact value that does nothing when it is pressed.
+ * It is not metadata — that is `badge`, and the two share this tone and this
+ * type scale on purpose — and it never becomes a command by accident: a chip
+ * that acts is `TagButton`, one that navigates is `TagLink`, and one that
+ * holds a selection is `TagToggle`.
+ *
+ * It can still be removed. A static chip with an X is the commonest shape in
+ * the field, and the X is a control while the chip around it is not.
+ *
+ * The member's own props land on the chip box, which is the element a static
+ * tag is, and `render` puts that box into another element — an `<li>` in a
+ * list, a `<dd>` in a description list.
+ */
+export declare function Tag({ children, disabled, end, onRemove, removeDisabled, messages, render, shape, size, start, tone, variant, ...nativeProps }: TagProps): import("react").JSX.Element;
+//# sourceMappingURL=tag.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../../src/tag/tag.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,GAAG,CAAC,EAClB,QAAQ,EACR,QAAgB,EAChB,GAAG,EACH,QAAQ,EACR,cAAsB,EACtB,QAAQ,EACR,MAAM,EACN,KAAK,EACL,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,OAAO,EACP,GAAG,WAAW,EACf,EAAE,QAAQ,+BAuBV"}

package/dist/types/tag/tag.types.d.ts

@@ -0,0 +1,153 @@
+import type { PartialMessages, TagMessages } from '@slotted/core/i18n';
+import type { ChangeReason } from '@slotted/core/state';
+import type { ComponentPropsWithRef, HTMLAttributes, ReactNode, Ref, SyntheticEvent } from 'react';
+/** Which of the five semantic colours the tag speaks in. */
+export type TagTone = 'accent' | 'secondary' | 'success' | 'warning' | 'danger';
+/** How that colour is painted. `soft` is the tinted chip a tag usually is. */
+export type TagVariant = 'solid' | 'soft' | 'outline';
+export type TagSize = 'sm' | 'md' | 'lg';
+export type TagShape = 'pill' | 'square';
+export type TagOrientation = 'horizontal' | 'vertical';
+/**
+ * How the removal was asked for. `remove` is the control at the end of the
+ * chip; `keyboard` is `Backspace` or `Delete` pressed on the chip itself. A
+ * bare callback cannot tell the two apart, and a confirmation flow wants one
+ * and not the other.
+ */
+export type TagRemoveReason = Extract<ChangeReason, 'remove' | 'keyboard'>;
+/**
+ * A request to be taken out of the collection that holds the tag, and never a
+ * value: the tag does not own whether it exists.
+ *
+ * Refusing it is what stops the group from moving focus, which is the one
+ * thing the family would otherwise commit on its own. A confirmation that the
+ * person has not answered yet leaves the keyboard where it is.
+ */
+export interface TagRemoveRequest {
+    readonly reason: TagRemoveReason;
+    /** The event the request came from. */
+    readonly source: SyntheticEvent;
+    readonly cancelled: boolean;
+    /** Refuses the request: nothing is removed and focus does not move. */
+    cancel(): void;
+}
+/** What an application sets once for every tag under it. */
+export interface TagDefaults {
+    shape: TagShape;
+    size: TagSize;
+    tone: TagTone;
+    variant: TagVariant;
+}
+export interface TagDefaultsProviderProps extends Partial<TagDefaults> {
+    children?: ReactNode | undefined;
+}
+export interface TagAppearanceProps {
+    /** Defaults to the provider, then to `secondary`. */
+    tone?: TagTone | undefined;
+    /** Defaults to the provider, then to `soft`. */
+    variant?: TagVariant | undefined;
+    /** Defaults to the provider, then to `md`. */
+    size?: TagSize | undefined;
+    /** Defaults to the provider, then to `pill`. */
+    shape?: TagShape | undefined;
+}
+export interface TagContentProps {
+    children?: ReactNode | undefined;
+    /**
+     * A glyph or an avatar before the words, wrapped in the `start` part, which
+     * sizes and centres it. The artwork is the consumer's.
+     */
+    start?: ReactNode | undefined;
+    /** A glyph after the words, wrapped in the `end` part. */
+    end?: ReactNode | undefined;
+}
+export interface TagRemovableProps {
+    /**
+     * Asks to be removed. The tag renders its remove control only when this is
+     * present, because a chip with an X that does nothing is worse than a chip
+     * without one.
+     */
+    onRemove?: ((request: TagRemoveRequest) => void) | undefined;
+    /**
+     * Words laid over the catalog of the language in force, key by key: `remove`
+     * is the word the remove control announces before the tag's own label, so it
+     * reads "Remove Design" rather than "Remove".
+     */
+    messages?: PartialMessages<TagMessages> | undefined;
+    /** Refuses the removal while leaving the rest of the tag operable. */
+    removeDisabled?: boolean | undefined;
+}
+/** Props the family writes on whichever element a member's `render` returns. */
+export interface TagElementProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode | undefined;
+    'data-part': string;
+}
+export interface TagRootProps extends TagElementProps {
+    'data-shape': TagShape;
+    'data-size': TagSize;
+    'data-tone': TagTone;
+    'data-ui': string;
+    'data-variant': TagVariant;
+}
+/** What is written on the chip box when a member's own props land elsewhere. */
+export type TagRootPassthrough = Omit<ComponentPropsWithRef<'span'>, 'children' | `data-${string}`>;
+interface TagSharedProps extends TagAppearanceProps, TagContentProps, TagRemovableProps {
+    /** Refuses every interaction the tag offers, including its removal. */
+    disabled?: boolean | undefined;
+}
+export interface TagProps extends TagSharedProps, Omit<ComponentPropsWithRef<'span'>, 'children'> {
+    /** Renders the chip box into the element the page means — an `<li>`, a `<dd>`. */
+    render?: ((props: TagRootProps) => ReactNode) | undefined;
+}
+interface TagInteractiveProps extends TagSharedProps {
+    /** Reaches the chip box, which the member's own props do not land on. */
+    rootProps?: TagRootPassthrough | undefined;
+}
+/** What a member writes on the control it renders, native props included. */
+export interface TagButtonBodyProps extends ComponentPropsWithRef<'button'> {
+    'data-part': string;
+}
+export interface TagLinkBodyProps extends ComponentPropsWithRef<'a'> {
+    'data-part': string;
+}
+export interface TagButtonProps extends TagInteractiveProps, Omit<ComponentPropsWithRef<'button'>, 'children'> {
+    /** Renders the control into another element — a menu trigger, a router link. */
+    render?: ((props: TagButtonBodyProps) => ReactNode) | undefined;
+}
+export interface TagLinkProps extends TagInteractiveProps, Omit<ComponentPropsWithRef<'a'>, 'children'> {
+    /** Renders the destination into a router's own link component. */
+    render?: ((props: TagLinkBodyProps) => ReactNode) | undefined;
+}
+export interface TagToggleProps extends TagInteractiveProps, Omit<ComponentPropsWithRef<'button'>, 'children'> {
+    /** The selection the consumer owns. Passing it decides the mode for good. */
+    selected?: boolean | undefined;
+    /** The selection an uncontrolled tag starts from, read once. */
+    defaultSelected?: boolean | undefined;
+    /** Asks for the opposite selection, carrying the reason and the event. */
+    onSelectedChange?: ((selected: boolean, request: {
+        reason: ChangeReason;
+        cancel(): void;
+    }) => void) | undefined;
+    render?: ((props: TagButtonBodyProps) => ReactNode) | undefined;
+}
+export interface TagGroupRootProps extends TagElementProps {
+    'data-orientation': TagOrientation;
+    'data-ui': string;
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+export interface TagGroupProps extends Omit<ComponentPropsWithRef<'div'>, 'children'> {
+    children?: ReactNode | undefined;
+    /** Which way the run reads. `vertical` also writes `aria-orientation`. */
+    orientation?: TagOrientation | undefined;
+    /** Whether the arrow keys wrap past the ends. */
+    loop?: boolean | undefined;
+    /**
+     * `toolbar` by default, which is what makes the run one tab stop with arrow
+     * navigation inside it. Writing `list` turns that off: a list is a structure
+     * rather than a widget, and its items are not controls to move between.
+     */
+    role?: string | undefined;
+    render?: ((props: TagGroupRootProps) => ReactNode) | undefined;
+}
+export {};
+//# sourceMappingURL=tag.types.d.ts.map

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

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

package/dist/types/tags-input/index.d.ts

@@ -0,0 +1,4 @@
+export { TagsInput } from './tags-input';
+export { TAGS_INPUT_FALLBACK, TagsInputDefaultsProvider, useTagsInputDefaults, } from './tags-input-defaults';
+export type { TagsInputDefaults, TagsInputDefaultsProviderProps, TagsInputHandle, TagsInputInputReason, TagsInputInvalidValues, TagsInputNativeProps, TagsInputOverflow, TagsInputPendingOnBlur, TagsInputProps, TagsInputRefuseCause, TagsInputRootProps, TagsInputSize, TagsInputValueReason, TagsInputVariant, } from './tags-input.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/tags-input/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tags-input/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,iBAAiB,EACjB,8BAA8B,EAC9B,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,iBAAiB,EACjB,sBAAsB,EACtB,cAAc,EACd,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC"}

package/dist/types/tags-input/tags-input-chips.d.ts

@@ -0,0 +1,42 @@
+import type { FamilyTranslator, TagsInputMessages } from '@slotted/core/i18n';
+import type { TagsVerdict } from '@slotted/core/tags';
+import type { ReactNode } from 'react';
+/** The chips in the row, in the order the row holds them. */
+export declare const CHIP_SELECTOR = "[data-part='chips'] > [role='gridcell']:not([data-part='field'])";
+/** What the row and its chips read from the control that renders them. */
+export interface TagsInputChipsContext {
+    announce: (message: string) => void;
+    /** The row is one line and a `+N` at rest, and every chip while focus is within. */
+    collapsing: boolean;
+    copy: (value: string) => void;
+    disabled: boolean;
+    /** The value a refused duplicate is already held under, for its chip to take focus. */
+    duplicate: string | null;
+    editable: boolean;
+    inputNode: HTMLInputElement | null;
+    labelFor: (value: string) => string;
+    lockedValues: readonly string[];
+    move: (from: number, to: number, source?: unknown) => void;
+    readOnly: boolean;
+    remove: (index: number, source?: unknown) => void;
+    reorderable: boolean;
+    replace: (index: number, text: string, source?: unknown) => void;
+    /** The family's words in the language in force. */
+    t: FamilyTranslator<TagsInputMessages>;
+    value: readonly string[];
+    verdicts: readonly TagsVerdict[];
+}
+export interface ChipRowProps {
+    /** The field cell, which is the last cell of the row. */
+    children: ReactNode;
+    context: TagsInputChipsContext;
+    describedBy: string;
+    label: string;
+}
+/**
+ * The row: one `role="row"` holding one cell per value and the field at the
+ * end. One DOM row, however many lines it draws — the wrap is CSS, so the
+ * reading order stays linear and "previous" and "next" have one meaning each.
+ */
+export declare function ChipRow({ children, context, describedBy, label }: ChipRowProps): import("react").JSX.Element;
+//# sourceMappingURL=tags-input-chips.d.ts.map

package/dist/types/tags-input/tags-input-chips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags-input-chips.d.ts","sourceRoot":"","sources":["../../../src/tags-input/tags-input-chips.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAI9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,KAAK,EAA6B,SAAS,EAAE,MAAM,OAAO,CAAC;AAIlE,6DAA6D;AAC7D,eAAO,MAAM,aAAa,qEAAqE,CAAC;AAEhG,0EAA0E;AAC1E,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,oFAAoF;IACpF,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,QAAQ,EAAE,OAAO,CAAC;IAClB,uFAAuF;IACvF,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACnC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAC3D,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IACjE,mDAAmD;IACnD,CAAC,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,CAAC;IACvC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAClC;AAuPD,MAAM,WAAW,YAAY;IAC3B,yDAAyD;IACzD,QAAQ,EAAE,SAAS,CAAC;IACpB,OAAO,EAAE,qBAAqB,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,EAAE,YAAY,+BA2G9E"}

package/dist/types/tags-input/tags-input-defaults.d.ts

@@ -0,0 +1,30 @@
+import type { TagsInputDefaults, TagsInputDefaultsProviderProps } from './tags-input.types';
+/**
+ * The numbers, and why they are these numbers.
+ *
+ * `invalidValues` is `keep`. It is the reason the family exists beside
+ * `multi-select`: a recipients field that silently drops `jhon.company` has
+ * told the reader John was invited. `refuse` is for a filter operand, where a
+ * bad value has nowhere to go.
+ *
+ * `pendingOnBlur` is `commit`: a reader who typed an address and pressed the
+ * submit button meant it. `keep` is the filter operand's answer and `discard`
+ * a chat box's, and both are one word away.
+ *
+ * `delimiters` is the comma alone — the one separator every surveyed
+ * implementation ships, and a space would make a two-word value impossible
+ * to type. Line breaks split a paste whatever this says.
+ *
+ * `max` is `null`. A limit is a rule about the consumer's data, and a family
+ * that invented one would refuse a value for a reason nobody wrote.
+ */
+export declare const TAGS_INPUT_FALLBACK: TagsInputDefaults;
+/** The defaults in force here. The family reads it; a consumer rarely needs to. */
+export declare function useTagsInputDefaults(): TagsInputDefaults;
+/**
+ * The decisions an application takes once, in its bootstrap, rather than on
+ * every control it renders. Its words come from the language in force
+ * (`SlottedProvider`).
+ */
+export declare function TagsInputDefaultsProvider({ children, ...overrides }: TagsInputDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=tags-input-defaults.d.ts.map

package/dist/types/tags-input/tags-input-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags-input-defaults.d.ts","sourceRoot":"","sources":["../../../src/tags-input/tags-input-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AAE5F;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,EAAE,iBAkBjC,CAAC;AAIF,mFAAmF;AACnF,wBAAgB,oBAAoB,IAAI,iBAAiB,CAExD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,EACR,GAAG,SAAS,EACb,EAAE,8BAA8B,+BAYhC"}

package/dist/types/tags-input/tags-input.d.ts

@@ -0,0 +1,28 @@
+
+
+import type { TagsInputProps } from './tags-input.types';
+/** The width, in CSS pixels, under which a chip has no room for a word. */
+export declare const NARROW_WIDTH = 120;
+/**
+ * A frame of typed values, with a field that adds more.
+ *
+ * **The value is a list of texts, and the text is the label.** There is no
+ * collection behind it, which is what separates this family from
+ * `multi-select`: a value comes from the reader's keyboard or clipboard and
+ * from nowhere else.
+ *
+ * **A value that fails is held and shown.** Every value in the list is judged
+ * at render — by `validate`, or by the input's own constraints through the
+ * browser — and a value that fails wears the danger tone, the alert mark and a
+ * description, marks the root, and blocks the native submit through
+ * `setCustomValidity`. Every surveyed implementation drops it instead, and a
+ * recipients field that silently drops `jhon.company` has told the reader John
+ * was invited. `invalidValues="refuse"` is that behaviour, for the operand of
+ * a filter, where a bad value has nowhere to go.
+ *
+ * **What is refused is reported, not dropped.** A duplicate, a value past the
+ * limit, and — under `refuse` — an invalid one each leave through
+ * `onValueRefuse` with the cause.
+ */
+export declare function TagsInput({ className, defaultInputValue, defaultValue, formatLabel, handleRef, inputValue, locale: localeProp, lockedValues, messages, normalize, onValueCopy, onInputValueChange, onValueChange, onValueRefuse, ref, render, split, style, type, validate, value, ...rest }: TagsInputProps): 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=tags-input.d.ts.map

package/dist/types/tags-input/tags-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags-input.d.ts","sourceRoot":"","sources":["../../../src/tags-input/tags-input.tsx"],"names":[],"mappings":"AAKA,OAAO,2CAA2C,CAAC;AACnD,OAAO,6BAA6B,CAAC;AAkCrC,OAAO,KAAK,EAIV,cAAc,EAGf,MAAM,oBAAoB,CAAC;AAE5B,2EAA2E;AAC3E,eAAO,MAAM,YAAY,MAAM,CAAC;AAqChC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,EACxB,SAAS,EACT,iBAAsB,EACtB,YAAiB,EACjB,WAAW,EACX,SAAS,EACT,UAAU,EACV,MAAM,EAAE,UAAU,EAClB,YAAiB,EACjB,QAAQ,EACR,SAAS,EACT,WAAW,EACX,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,GAAG,EACH,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAa,EACb,QAAQ,EACR,KAAK,EACL,GAAG,IAAI,EACR,EAAE,cAAc,+VA+gBhB"}