@gamecrafters/base-ui 0.0.41 → 0.0.42

package/build/components/index.d.ts

@@ -66,6 +66,7 @@ export * from "./keybinding-hint";
 export * from "./label";
 export * from "./label-group";
 export * from "./layer-card";
+export * from "./layer-dialog";
 export * from "./link";
 export * from "./list";
 export * from "./map";
@@ -116,6 +117,7 @@ export * from "./swap";
 export * from "./switch";
 export * from "./table-of-contents";
 export * from "./tabs";
+export * from "./tag-input";
 export * from "./text";
 export * from "./text-input";
 export * from "./textarea";

package/build/components/layer-dialog/LayerDialog.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { LayerDialogProps } from "./LayerDialog.types";
+declare function LayerDialog(props: LayerDialogProps): React.JSX.Element;
+declare namespace LayerDialog {
+    var displayName: string;
+}
+export default LayerDialog;

package/build/components/layer-dialog/LayerDialog.types.d.ts

@@ -0,0 +1,65 @@
+import type * as React from "react";
+import type { ButtonProps } from "../button";
+export type LayerDialogOpenChangeGesture = "trigger-press" | "close-button" | "dismiss-button" | "escape" | "click-outside" | "swipe" | "imperative";
+export type LayerDialogSize = "small" | "medium" | "large" | "xlarge";
+export type LayerDialogVerticalAlign = "top" | "center";
+export type LayerDialogActionVariant = "primary" | "danger";
+export type LayerDialogInstance = {
+    close: () => void;
+};
+export type LayerDialogProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean, gesture: LayerDialogOpenChangeGesture) => void;
+    dismissDisabled?: boolean;
+    modal?: boolean;
+    disablePointerDismissal?: boolean;
+    actionsRef?: React.Ref<LayerDialogInstance | null>;
+    children?: React.ReactNode;
+};
+export type LayerDialogAlertProps = LayerDialogProps;
+export type LayerDialogTriggerProps<As extends React.ElementType = "button"> = ButtonProps<As>;
+export type LayerDialogContentProps = {
+    children: React.ReactNode;
+    size?: LayerDialogSize;
+    verticalAlign?: LayerDialogVerticalAlign;
+    closeLabel?: string;
+    portalContainerName?: string;
+    initialFocusRef?: React.RefObject<HTMLElement | null>;
+    returnFocusRef?: React.RefObject<HTMLElement | null>;
+    className?: string;
+};
+export type LayerDialogTitleProps = Omit<React.ComponentPropsWithoutRef<"h2">, "id"> & {
+    className?: string;
+};
+export type LayerDialogDescriptionProps = Omit<React.ComponentPropsWithoutRef<"p">, "id"> & {
+    className?: string;
+};
+export type LayerDialogBodyProps = {
+    children?: React.ReactNode;
+    className?: string;
+};
+export type LayerDialogActionsProps = {
+    children: React.ReactNode;
+    dismissLabel?: string;
+    className?: string;
+};
+export type LayerDialogActionProps = Omit<ButtonProps, "as" | "variant" | "size" | "block" | "children"> & {
+    children: React.ReactNode;
+    variant?: LayerDialogActionVariant;
+    menu?: React.ReactNode[];
+    menuLabel?: string;
+};
+export type LayerDialogContextValue = {
+    open: boolean;
+    setOpen: (open: boolean, gesture: LayerDialogOpenChangeGesture) => void;
+    dismiss: (gesture: LayerDialogOpenChangeGesture) => void;
+    alert: boolean;
+    modal: boolean;
+    dismissDisabled: boolean;
+    pointerDismissal: boolean;
+    narrow: boolean;
+    popupId: string;
+    titleId: string;
+    descriptionId: string;
+};

package/build/components/layer-dialog/LayerDialogAction.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: (props: Omit<import("..").ButtonProps, "size" | "as" | "children" | "variant" | "block"> & {
+    children: React.ReactNode;
+    variant?: import("./LayerDialog.types").LayerDialogActionVariant;
+    menu?: React.ReactNode[];
+    menuLabel?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogActions.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { LayerDialogActionsProps } from "./LayerDialog.types";
+declare const _default: (props: LayerDialogActionsProps & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogAlert.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { LayerDialogAlertProps } from "./LayerDialog.types";
+declare function LayerDialogAlert(props: LayerDialogAlertProps): React.JSX.Element;
+declare namespace LayerDialogAlert {
+    var displayName: string;
+}
+export default LayerDialogAlert;

package/build/components/layer-dialog/LayerDialogBody.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { LayerDialogBodyProps } from "./LayerDialog.types";
+declare const _default: (props: LayerDialogBodyProps & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogContent.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { LayerDialogContentProps } from "./LayerDialog.types";
+declare const _default: (props: LayerDialogContentProps & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogContext.d.ts

@@ -0,0 +1,12 @@
+import type * as React from "react";
+import type { LayerDialogContextValue } from "./LayerDialog.types";
+export declare const LayerDialogContext: React.Context<LayerDialogContextValue>;
+export declare const useLayerDialogContext: () => LayerDialogContextValue;
+export type LayerDialogBodySlots = {
+    title: React.ReactNode;
+    description: React.ReactNode;
+    actions: React.ReactNode;
+    showCloseButton: boolean;
+    closeLabel: string;
+};
+export declare const LayerDialogBodySlotsContext: React.Context<LayerDialogBodySlots>;

package/build/components/layer-dialog/LayerDialogDescription.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref">, "id"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogPopup.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { UsePresenceReturn } from "../presence";
+import type { LayerDialogContentProps } from "./LayerDialog.types";
+declare const _default: (props: Omit<LayerDialogContentProps, "children" | "closeLabel"> & {
+    presence: UsePresenceReturn;
+    actions?: React.ReactNode;
+    children: React.ReactNode;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogTitle.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref">, "id"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogTrigger.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "button">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "button" : As> & import("..").ButtonBaseProps & import("..").ButtonContentProps, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/index.d.ts

@@ -0,0 +1,34 @@
+import LayerDialogBase from "./LayerDialog";
+import LayerDialogAction from "./LayerDialogAction";
+import LayerDialogActions from "./LayerDialogActions";
+import LayerDialogAlert from "./LayerDialogAlert";
+import LayerDialogBody from "./LayerDialogBody";
+import LayerDialogContent from "./LayerDialogContent";
+import LayerDialogDescription from "./LayerDialogDescription";
+import LayerDialogTitle from "./LayerDialogTitle";
+import LayerDialogTrigger from "./LayerDialogTrigger";
+export declare const LayerDialog: typeof LayerDialogBase & {
+    Root: typeof LayerDialogBase;
+    Alert: typeof LayerDialogAlert;
+    Trigger: <As extends React.ElementType = "button">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "button" : As> & import("..").ButtonBaseProps & import("..").ButtonContentProps, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Content: (props: import("./LayerDialog.types").LayerDialogContentProps & import("react").RefAttributes<any>) => React.ReactNode;
+    Title: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref">, "id"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Description: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref">, "id"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Body: (props: import("./LayerDialog.types").LayerDialogBodyProps & import("react").RefAttributes<any>) => React.ReactNode;
+    Actions: (props: import("./LayerDialog.types").LayerDialogActionsProps & import("react").RefAttributes<any>) => React.ReactNode;
+    Action: (props: Omit<import("..").ButtonProps, "size" | "as" | "children" | "variant" | "block"> & {
+        children: React.ReactNode;
+        variant?: import("./LayerDialog.types").LayerDialogActionVariant;
+        menu?: React.ReactNode[];
+        menuLabel?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { LayerDialogAlert, LayerDialogTrigger, LayerDialogContent, LayerDialogTitle, LayerDialogDescription, LayerDialogBody, LayerDialogActions, LayerDialogAction, };
+export { LayerDialogContext, useLayerDialogContext } from "./LayerDialogContext";
+export * from "./LayerDialog.types";

package/build/components/layer-dialog/useLayerDialog.d.ts

@@ -0,0 +1,6 @@
+import type { LayerDialogContextValue, LayerDialogProps } from "./LayerDialog.types";
+type UseLayerDialogProps = Omit<LayerDialogProps, "children"> & {
+    alert: boolean;
+};
+export declare const useLayerDialog: (props: UseLayerDialogProps) => LayerDialogContextValue;
+export {};

package/build/components/tag-input/TagInput.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof import("./TagInput.types").UseTagInputProps> & import("./TagInput.types").UseTagInputProps & {
+    size?: import("..").TextInputSize;
+    block?: boolean;
+    contrast?: boolean;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/TagInput.types.d.ts

@@ -0,0 +1,175 @@
+import type * as React from "react";
+import type { ButtonVisual } from "../button";
+import type { TextInputSize } from "../text-input/TextInput.types";
+export type TagInputInvalidReason = "rangeOverflow" | "invalidTag";
+export type TagInputBlurBehavior = "add" | "clear";
+export type TagInputTranslations = {
+    clearTriggerLabel?: string;
+    deleteTagTriggerLabel?: (value: string) => string;
+    tagAdded?: (value: string) => string;
+    tagsPasted?: (values: string[]) => string;
+    tagEdited?: (value: string) => string;
+    tagUpdated?: (value: string) => string;
+    tagDeleted?: (value: string) => string;
+    tagSelected?: (value: string) => string;
+    noTagsSelected?: string;
+};
+export type TagInputIds = {
+    root?: string;
+    label?: string;
+    control?: string;
+    input?: string;
+    hiddenInput?: string;
+    clearTrigger?: string;
+};
+export type TagInputItemIds = {
+    item: string;
+    preview: string;
+    input: string;
+    deleteTrigger: string;
+};
+export type UseTagInputProps = {
+    value?: string[];
+    defaultValue?: string[];
+    inputValue?: string;
+    defaultInputValue?: string;
+    delimiter?: string | RegExp;
+    max?: number;
+    allowOverflow?: boolean;
+    maxLength?: number;
+    allowDuplicates?: boolean;
+    addOnPaste?: boolean;
+    blurBehavior?: TagInputBlurBehavior;
+    editable?: boolean;
+    sanitizeValue?: (value: string) => string;
+    validate?: (inputValue: string, value: string[]) => boolean;
+    placeholder?: string;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    name?: string;
+    form?: string;
+    id?: string;
+    ids?: TagInputIds;
+    translations?: TagInputTranslations;
+    onValueChange?: (value: string[]) => void;
+    onInputValueChange?: (inputValue: string) => void;
+    onHighlightChange?: (highlightedValue: string | null) => void;
+    onValueInvalid?: (reason: TagInputInvalidReason) => void;
+};
+export type TagInputItemOptions = {
+    index: number;
+    value: string;
+    disabled?: boolean;
+};
+export type TagInputItemState = {
+    index: number;
+    value: string;
+    ids: TagInputItemIds;
+    editing: boolean;
+    highlighted: boolean;
+    disabled: boolean;
+};
+export type TagInputAnnouncement = {
+    message: string;
+    count: number;
+};
+export type UseTagInputReturn = {
+    value: string[];
+    valueAsString: string;
+    inputValue: string;
+    count: number;
+    empty: boolean;
+    atMax: boolean;
+    focused: boolean;
+    highlightedIndex: number | null;
+    editingIndex: number | null;
+    editedValue: string;
+    placeholder?: string;
+    maxLength?: number;
+    editable: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    required: boolean;
+    invalid: boolean;
+    name?: string;
+    form?: string;
+    ids: Required<TagInputIds>;
+    describedBy?: string;
+    translations: Required<TagInputTranslations>;
+    announcement: TagInputAnnouncement;
+    setValue: (value: string[]) => void;
+    clearValue: (index?: number) => void;
+    addValue: (value: string) => void;
+    setValueAtIndex: (index: number, value: string) => void;
+    setInputValue: (value: string) => void;
+    clearInputValue: () => void;
+    focus: () => void;
+    getItemState: (options: TagInputItemOptions) => TagInputItemState;
+    rootRef: React.RefObject<HTMLDivElement | null>;
+    handleRootFocus: () => void;
+    handleControlMouseDown: (event: React.MouseEvent<HTMLElement>) => void;
+    handleInputChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    handleInputKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    handleInputPaste: () => void;
+    handleItemPreviewMouseDown: (event: React.MouseEvent<HTMLElement>, options: TagInputItemOptions) => void;
+    handleItemPreviewDoubleClick: (options: TagInputItemOptions) => void;
+    handleItemInputChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    handleItemInputKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    handleItemInputBlur: () => void;
+    handleItemDelete: (options: TagInputItemOptions) => void;
+    handleClear: () => void;
+};
+type TagInputFieldProps = {
+    size?: TextInputSize;
+    block?: boolean;
+    contrast?: boolean;
+    className?: string;
+};
+export type TagInputProps = Omit<React.ComponentPropsWithoutRef<"div">, keyof UseTagInputProps> & UseTagInputProps & TagInputFieldProps;
+export type TagInputRootProviderProps = Omit<React.ComponentPropsWithoutRef<"div">, "defaultValue"> & TagInputFieldProps & {
+    value: UseTagInputReturn;
+};
+export type TagInputLabelProps = React.ComponentPropsWithoutRef<"label"> & {
+    visuallyHidden?: boolean;
+    className?: string;
+};
+export type TagInputControlProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type TagInputInputProps = Omit<React.ComponentPropsWithoutRef<"input">, "value" | "defaultValue" | "size"> & {
+    className?: string;
+};
+export type TagInputClearTriggerProps = Omit<React.ComponentPropsWithoutRef<"button">, "children" | "aria-label" | "aria-labelledby"> & {
+    icon?: ButtonVisual;
+    label?: string;
+    className?: string;
+};
+export type TagInputItemProps = Omit<React.ComponentPropsWithoutRef<"div">, "children"> & TagInputItemOptions & {
+    children?: React.ReactNode;
+    className?: string;
+};
+export type TagInputItemPreviewProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type TagInputItemTextProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type TagInputItemInputProps = Omit<React.ComponentPropsWithoutRef<"input">, "value" | "defaultValue" | "size"> & {
+    className?: string;
+};
+export type TagInputItemDeleteTriggerProps = Omit<React.ComponentPropsWithoutRef<"button">, "aria-label" | "aria-labelledby"> & {
+    label?: string;
+    className?: string;
+};
+export type TagInputHiddenInputProps = Omit<React.ComponentPropsWithoutRef<"input">, "value" | "defaultValue" | "type">;
+export type TagInputConsumerProps = {
+    children: (tagInput: UseTagInputReturn) => React.ReactNode;
+};
+export type TagInputItemConsumerProps = {
+    children: (item: TagInputItemState) => React.ReactNode;
+};
+export type TagInputContextValue = UseTagInputReturn & Omit<TagInputFieldProps, "className">;
+export {};

package/build/components/tag-input/TagInputClearTrigger.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "aria-label" | "aria-labelledby" | "children"> & {
+    icon?: import("..").ButtonVisual;
+    label?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/TagInputConsumer.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { TagInputConsumerProps } from "./TagInput.types";
+declare function TagInputConsumer({ children }: TagInputConsumerProps): React.JSX.Element | null;
+declare namespace TagInputConsumer {
+    var displayName: string;
+}
+export default TagInputConsumer;

package/build/components/tag-input/TagInputContext.d.ts

@@ -0,0 +1,17 @@
+import type { TagInputContextValue, TagInputItemState, UseTagInputReturn } from "./TagInput.types";
+export declare const TagInputContext: import("react").Context<TagInputContextValue | undefined>;
+export declare const useTagInputContext: () => TagInputContextValue | undefined;
+export declare const TagInputItemContext: import("react").Context<TagInputItemState | undefined>;
+export declare const useTagInputItemContext: () => TagInputItemState | undefined;
+export declare const getStateAttributes: ({ focused, disabled, readOnly, invalid, empty, }: Pick<UseTagInputReturn, "focused" | "disabled" | "readOnly" | "invalid" | "empty">) => {
+    "data-focus": true | undefined;
+    "data-disabled": true | undefined;
+    "data-readonly": true | undefined;
+    "data-invalid": true | undefined;
+    "data-empty": true | undefined;
+};
+export declare const getItemStateAttributes: ({ highlighted, editing, disabled, }: Pick<TagInputItemState, "highlighted" | "editing" | "disabled">) => {
+    "data-highlighted": true | undefined;
+    "data-editing": true | undefined;
+    "data-disabled": true | undefined;
+};

package/build/components/tag-input/TagInputControl.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/TagInputHiddenInput.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { TagInputHiddenInputProps } from "./TagInput.types";
+declare const _default: (props: TagInputHiddenInputProps & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/TagInputInput.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, "size" | "value" | "defaultValue"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/TagInputItem.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & import("./TagInput.types").TagInputItemOptions & {
+    children?: React.ReactNode;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/TagInputItemConsumer.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { TagInputItemConsumerProps } from "./TagInput.types";
+declare function TagInputItemConsumer({ children }: TagInputItemConsumerProps): React.JSX.Element | null;
+declare namespace TagInputItemConsumer {
+    var displayName: string;
+}
+export default TagInputItemConsumer;

package/build/components/tag-input/TagInputItemDeleteTrigger.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "aria-label" | "aria-labelledby"> & {
+    label?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/TagInputItemInput.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, "size" | "value" | "defaultValue"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/TagInputItemPreview.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/TagInputItemText.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/TagInputLabel.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+    visuallyHidden?: boolean;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/TagInputRootProvider.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue"> & {
+    size?: import("..").TextInputSize;
+    block?: boolean;
+    contrast?: boolean;
+    className?: string;
+} & {
+    value: import("./TagInput.types").UseTagInputReturn;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tag-input/index.d.ts

@@ -0,0 +1,73 @@
+import TagInputClearTrigger from "./TagInputClearTrigger";
+import TagInputConsumer from "./TagInputConsumer";
+import TagInputControl from "./TagInputControl";
+import TagInputHiddenInput from "./TagInputHiddenInput";
+import TagInputInput from "./TagInputInput";
+import TagInputItem from "./TagInputItem";
+import TagInputItemConsumer from "./TagInputItemConsumer";
+import TagInputItemDeleteTrigger from "./TagInputItemDeleteTrigger";
+import TagInputItemInput from "./TagInputItemInput";
+import TagInputItemPreview from "./TagInputItemPreview";
+import TagInputItemText from "./TagInputItemText";
+import TagInputLabel from "./TagInputLabel";
+import TagInputRootProvider from "./TagInputRootProvider";
+export declare const TagInput: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof import("./TagInput.types").UseTagInputProps> & import("./TagInput.types").UseTagInputProps & {
+    size?: import("..").TextInputSize;
+    block?: boolean;
+    contrast?: boolean;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Root: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof import("./TagInput.types").UseTagInputProps> & import("./TagInput.types").UseTagInputProps & {
+        size?: import("..").TextInputSize;
+        block?: boolean;
+        contrast?: boolean;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    RootProvider: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue"> & {
+        size?: import("..").TextInputSize;
+        block?: boolean;
+        contrast?: boolean;
+        className?: string;
+    } & {
+        value: import("./TagInput.types").UseTagInputReturn;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Context: typeof TagInputConsumer;
+    Label: (props: Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+        visuallyHidden?: boolean;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Control: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Input: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, "size" | "value" | "defaultValue"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ClearTrigger: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "aria-label" | "aria-labelledby" | "children"> & {
+        icon?: import("..").ButtonVisual;
+        label?: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Item: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & import("./TagInput.types").TagInputItemOptions & {
+        children?: React.ReactNode;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemContext: typeof TagInputItemConsumer;
+    ItemPreview: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemText: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemDeleteTrigger: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "aria-label" | "aria-labelledby"> & {
+        label?: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemInput: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, "size" | "value" | "defaultValue"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    HiddenInput: (props: import("./TagInput.types").TagInputHiddenInputProps & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { TagInputRootProvider, TagInputConsumer, TagInputLabel, TagInputControl, TagInputInput, TagInputClearTrigger, TagInputItem, TagInputItemConsumer, TagInputItemPreview, TagInputItemText, TagInputItemDeleteTrigger, TagInputItemInput, TagInputHiddenInput, };
+export { TagInputContext, TagInputItemContext, useTagInputContext, useTagInputItemContext, } from "./TagInputContext";
+export { useTagInput } from "./useTagInput";
+export * from "./TagInput.types";

package/build/components/tag-input/useTagInput.d.ts

@@ -0,0 +1,2 @@
+import type { UseTagInputProps, UseTagInputReturn } from "./TagInput.types";
+export declare const useTagInput: (props?: UseTagInputProps) => UseTagInputReturn;