@gamecrafters/base-ui 0.0.24 → 0.0.25

package/build/components/combobox/Combobox.d.ts

@@ -0,0 +1,36 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue" | "onSelect"> & {
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    onSelect?: (value: string) => void;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputValueChange?: (inputValue: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    highlightedValue?: string | null;
+    defaultHighlightedValue?: string | null;
+    onHighlightChange?: (highlightedValue: string | null) => void;
+    multiple?: boolean;
+    closeOnSelect?: boolean;
+    selectionBehavior?: import("./Combobox.types").ComboboxSelectionBehavior;
+    inputBehavior?: import("./Combobox.types").ComboboxInputBehavior;
+    allowCustomValue?: boolean;
+    loopFocus?: boolean;
+    openOnClick?: boolean;
+    openOnChange?: boolean;
+    openOnKeyPress?: boolean;
+    filter?: import("./Combobox.types").ComboboxFilter;
+    shouldFilter?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    invalid?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    name?: string;
+    form?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/Combobox.types.d.ts

@@ -0,0 +1,146 @@
+import type * as React from "react";
+import type { ButtonVisual } from "../button";
+import type { TextInputProps } from "../text-input";
+import type { AnchorAlignment, AnchorSide } from "../tooltip/anchoredPosition";
+export type ComboboxInputBehavior = "none" | "autohighlight" | "autocomplete";
+export type ComboboxSelectionBehavior = "replace" | "clear" | "preserve";
+export type ComboboxFilter = (label: string, inputValue: string) => boolean;
+export type ComboboxItemEntry = {
+    value: string;
+    label: string;
+    id: string;
+    groupId?: string;
+    disabled: boolean;
+};
+export type ComboboxContextValue = {
+    inputId: string;
+    labelId: string;
+    listId: string;
+    getItemId: (value: string) => string | undefined;
+    inputValue: string;
+    completion: string;
+    onType: (inputValue: string) => void;
+    setInputValue: (inputValue: string) => void;
+    value: string[];
+    isSelected: (value: string) => boolean;
+    select: (value: string) => void;
+    clear: () => void;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openAt: (end: "first" | "last") => void;
+    highlightedValue: string | null;
+    setHighlightedValue: (value: string | null) => void;
+    moveHighlight: (step: number) => void;
+    entries: ComboboxItemEntry[];
+    register: (entry: ComboboxItemEntry) => void;
+    unregister: (value: string) => void;
+    matches: string[];
+    isMatch: (value: string) => boolean;
+    multiple: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    invalid: boolean;
+    required: boolean;
+    placeholder?: string;
+    inputBehavior: ComboboxInputBehavior;
+    openOnClick: boolean;
+    openOnKeyPress: boolean;
+    inputRef: React.RefObject<HTMLInputElement | null>;
+    controlRef: React.RefObject<HTMLDivElement | null>;
+    contentRef: React.RefObject<HTMLDivElement | null>;
+};
+export type ComboboxItemGroupContextValue = {
+    groupId: string;
+    labelId: string;
+};
+export type ComboboxItemContextValue = {
+    value: string;
+    selected: boolean;
+    highlighted: boolean;
+    disabled: boolean;
+};
+export type ComboboxProps = Omit<React.ComponentPropsWithoutRef<"div">, "onSelect" | "defaultValue"> & {
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    onSelect?: (value: string) => void;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputValueChange?: (inputValue: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    highlightedValue?: string | null;
+    defaultHighlightedValue?: string | null;
+    onHighlightChange?: (highlightedValue: string | null) => void;
+    multiple?: boolean;
+    closeOnSelect?: boolean;
+    selectionBehavior?: ComboboxSelectionBehavior;
+    inputBehavior?: ComboboxInputBehavior;
+    allowCustomValue?: boolean;
+    loopFocus?: boolean;
+    openOnClick?: boolean;
+    openOnChange?: boolean;
+    openOnKeyPress?: boolean;
+    filter?: ComboboxFilter;
+    shouldFilter?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    invalid?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    name?: string;
+    form?: string;
+    className?: string;
+};
+export type ComboboxLabelProps = React.ComponentPropsWithoutRef<"label"> & {
+    className?: string;
+};
+export type ComboboxControlProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ComboboxInputProps = Omit<TextInputProps, "value" | "defaultValue" | "type" | "placeholder" | "disabled" | "readOnly" | "required"> & {
+    className?: string;
+};
+type ComboboxTriggerOwnProps = {
+    icon?: NonNullable<ButtonVisual>;
+    className?: string;
+};
+export type ComboboxTriggerProps = Omit<React.ComponentPropsWithoutRef<"button">, "aria-labelledby"> & ComboboxTriggerOwnProps;
+export type ComboboxClearTriggerProps = ComboboxTriggerProps;
+export type ComboboxPositionerProps = React.ComponentPropsWithoutRef<"div"> & {
+    side?: AnchorSide;
+    align?: AnchorAlignment;
+    portalContainerName?: string;
+    className?: string;
+};
+export type ComboboxContentProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ComboboxListProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ComboboxItemGroupProps = React.ComponentPropsWithoutRef<"div"> & {
+    forceMount?: boolean;
+    className?: string;
+};
+export type ComboboxItemGroupLabelProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ComboboxItemProps = Omit<React.ComponentPropsWithoutRef<"div">, "onSelect"> & {
+    value: string;
+    label?: string;
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    className?: string;
+};
+export type ComboboxItemTextProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type ComboboxItemIndicatorProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type ComboboxEmptyProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export {};

package/build/components/combobox/ComboboxClearTrigger.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-labelledby"> & {
+    icon?: NonNullable<import("..").ButtonVisual>;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxContent.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/combobox/ComboboxContext.d.ts

@@ -0,0 +1,4 @@
+import type { ComboboxContextValue, ComboboxItemContextValue, ComboboxItemGroupContextValue } from "./Combobox.types";
+export declare const ComboboxContext: import("react").Context<ComboboxContextValue | null>;
+export declare const ComboboxItemGroupContext: import("react").Context<ComboboxItemGroupContextValue | null>;
+export declare const ComboboxItemContext: import("react").Context<ComboboxItemContextValue | null>;

package/build/components/combobox/ComboboxControl.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/combobox/ComboboxEmpty.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/combobox/ComboboxInput.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<import("..").TextInputProps, "value" | "defaultValue" | "disabled" | "type" | "placeholder" | "readOnly" | "required"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxItem.d.ts

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

package/build/components/combobox/ComboboxItemGroup.d.ts

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

package/build/components/combobox/ComboboxItemGroupLabel.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/combobox/ComboboxItemIndicator.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/combobox/ComboboxItemText.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/combobox/ComboboxLabel.d.ts

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

package/build/components/combobox/ComboboxList.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/combobox/ComboboxPositioner.d.ts

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

package/build/components/combobox/ComboboxTrigger.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-labelledby"> & {
+    icon?: NonNullable<import("..").ButtonVisual>;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/index.d.ts

@@ -0,0 +1,104 @@
+import ComboboxClearTrigger from "./ComboboxClearTrigger";
+import ComboboxContent from "./ComboboxContent";
+import ComboboxControl from "./ComboboxControl";
+import ComboboxEmpty from "./ComboboxEmpty";
+import ComboboxInput from "./ComboboxInput";
+import ComboboxItem from "./ComboboxItem";
+import ComboboxItemGroup from "./ComboboxItemGroup";
+import ComboboxItemGroupLabel from "./ComboboxItemGroupLabel";
+import ComboboxItemIndicator from "./ComboboxItemIndicator";
+import ComboboxItemText from "./ComboboxItemText";
+import ComboboxLabel from "./ComboboxLabel";
+import ComboboxList from "./ComboboxList";
+import ComboboxPositioner from "./ComboboxPositioner";
+import ComboboxTrigger from "./ComboboxTrigger";
+export declare const Combobox: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue" | "onSelect"> & {
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    onSelect?: (value: string) => void;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputValueChange?: (inputValue: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    highlightedValue?: string | null;
+    defaultHighlightedValue?: string | null;
+    onHighlightChange?: (highlightedValue: string | null) => void;
+    multiple?: boolean;
+    closeOnSelect?: boolean;
+    selectionBehavior?: import("./Combobox.types").ComboboxSelectionBehavior;
+    inputBehavior?: import("./Combobox.types").ComboboxInputBehavior;
+    allowCustomValue?: boolean;
+    loopFocus?: boolean;
+    openOnClick?: boolean;
+    openOnChange?: boolean;
+    openOnKeyPress?: boolean;
+    filter?: import("./Combobox.types").ComboboxFilter;
+    shouldFilter?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    invalid?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    name?: string;
+    form?: string;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Label: (props: Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+        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<import("..").TextInputProps, "value" | "defaultValue" | "disabled" | "type" | "placeholder" | "readOnly" | "required"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Trigger: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "aria-labelledby"> & {
+        icon?: NonNullable<import("..").ButtonVisual>;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ClearTrigger: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "aria-labelledby"> & {
+        icon?: NonNullable<import("..").ButtonVisual>;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Positioner: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        side?: import("..").AnchorSide;
+        align?: import("..").AnchorAlignment;
+        portalContainerName?: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Content: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    List: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemGroup: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        forceMount?: boolean;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemGroupLabel: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Item: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+        value: string;
+        label?: string;
+        disabled?: boolean;
+        onSelect?: (value: string) => void;
+        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;
+    ItemIndicator: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Empty: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { ComboboxLabel, ComboboxControl, ComboboxInput, ComboboxTrigger, ComboboxClearTrigger, ComboboxPositioner, ComboboxContent, ComboboxList, ComboboxItemGroup, ComboboxItemGroupLabel, ComboboxItem, ComboboxItemText, ComboboxItemIndicator, ComboboxEmpty, };
+export { ComboboxContext, ComboboxItemContext, ComboboxItemGroupContext } from "./ComboboxContext";
+export * from "./Combobox.types";

package/build/components/index.d.ts

@@ -29,6 +29,7 @@ export * from "./clipboard";
 export * from "./code";
 export * from "./code-block";
 export * from "./collapsible";
+export * from "./combobox";
 export * from "./command-palette";
 export * from "./confirmation-dialog";
 export * from "./counter-label";
@@ -104,6 +105,7 @@ export * from "./state-label";
 export * from "./statistic-card";
 export * from "./status";
 export * from "./steps";
+export * from "./swap";
 export * from "./table-of-contents";
 export * from "./tabs";
 export * from "./text";
@@ -115,5 +117,6 @@ export * from "./toggle-switch";
 export * from "./token";
 export * from "./tooltip";
 export * from "./topic-tag";
+export * from "./tour";
 export * from "./tree-view";
 export * from "./truncate";

package/build/components/swap/Swap.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import type { SwapTransition } from "./Swap.types";
+declare const _default: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "span" : As> & {
+    swap?: boolean;
+    transition?: SwapTransition;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/swap/Swap.types.d.ts

@@ -0,0 +1,19 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type SwapIndicatorType = "on" | "off";
+export type SwapTransition = "fade" | "flip" | "rotate" | "scale" | "none";
+export type SwapProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    swap?: boolean;
+    transition?: SwapTransition;
+    className?: string;
+}>;
+type SwapIndicatorOwnProps = {
+    type: SwapIndicatorType;
+    className?: string;
+};
+export type SwapIndicatorProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", SwapIndicatorOwnProps>;
+export type SwapIndicatorElementProps = PolymorphicProps<"span", "span", SwapIndicatorOwnProps>;
+export type SwapContextValue = {
+    swap?: boolean;
+};
+export {};

package/build/components/swap/SwapContext.d.ts

@@ -0,0 +1,2 @@
+import type { SwapContextValue } from "./Swap.types";
+export declare const SwapContext: import("react").Context<SwapContextValue>;

package/build/components/swap/SwapIndicator.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "span" : As> & {
+    type: import("./Swap.types").SwapIndicatorType;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/swap/index.d.ts

@@ -0,0 +1,18 @@
+import SwapIndicator from "./SwapIndicator";
+export declare const Swap: (<As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "span" : As> & {
+    swap?: boolean;
+    transition?: import("./Swap.types").SwapTransition;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Indicator: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "span" : As> & {
+        type: import("./Swap.types").SwapIndicatorType;
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { SwapIndicator };
+export { SwapContext } from "./SwapContext";
+export * from "./Swap.types";

package/build/components/tour/Tour.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { TourProps } from "./Tour.types";
+export declare const DEFAULT_SPOTLIGHT_OFFSET = 4;
+export declare const DEFAULT_SPOTLIGHT_RADIUS = 8;
+declare function Tour(props: TourProps): React.JSX.Element;
+declare namespace Tour {
+    var displayName: string;
+}
+export default Tour;

package/build/components/tour/Tour.types.d.ts

@@ -0,0 +1,143 @@
+import type * as React from "react";
+import type { ButtonVariant, ButtonVisual } from "../button";
+import type { CaretProps } from "../caret";
+import type { AnchorAlignment, AnchorSide } from "../tooltip/anchoredPosition";
+export type TourStepType = "dialog" | "tooltip" | "floating";
+export type TourFloatingPlacement = "top-start" | "top-end" | "bottom-start" | "bottom-end";
+export type TourActionKind = "next" | "prev" | "dismiss";
+export type TourAction = {
+    label: string;
+    action: TourActionKind | ((tour: TourApi) => void);
+};
+export type TourStepUpdate = {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    actions?: TourAction[];
+};
+export type TourStepEffectArgs = {
+    next: () => void;
+    prev: () => void;
+    goto: (stepId: string) => void;
+    dismiss: () => void;
+    show: () => void;
+    update: (details: TourStepUpdate) => void;
+    target: () => HTMLElement | null;
+};
+export type TourStepEffectCleanup = (() => void) | void;
+export type TourStep = {
+    id: string;
+    type?: TourStepType;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    target?: () => HTMLElement | null;
+    side?: AnchorSide;
+    align?: AnchorAlignment;
+    placement?: TourFloatingPlacement;
+    actions?: TourAction[];
+    backdrop?: boolean;
+    arrow?: boolean;
+    effect?: (args: TourStepEffectArgs) => TourStepEffectCleanup;
+};
+export type TourStatus = "started" | "completed" | "dismissed";
+export type TourStatusChangeDetails = {
+    status: TourStatus;
+};
+export type TourStepChangeDetails = {
+    stepId: string | null;
+    stepIndex: number;
+    count: number;
+};
+export type TourRect = {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+};
+export type TourApi = {
+    open: boolean;
+    step: TourStep | null;
+    stepIndex: number;
+    steps: TourStep[];
+    start: (stepId?: string) => void;
+    next: () => void;
+    prev: () => void;
+    goto: (stepId: string) => void;
+    dismiss: () => void;
+    progressText: string;
+    progressPercent: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+};
+export type TourContextValue = TourApi & {
+    titleId: string;
+    descriptionId: string;
+    stepType: TourStepType;
+    ready: boolean;
+    targetRect: TourRect | null;
+    getTarget: () => HTMLElement | null;
+    spotlightOffset: number;
+    spotlightRadius: number;
+    contentRef: React.RefObject<HTMLDivElement | null>;
+};
+export type TourPositionerContextValue = {
+    side: AnchorSide;
+    align: AnchorAlignment;
+};
+export type TourProps = {
+    steps: TourStep[];
+    step?: string | null;
+    defaultStep?: string | null;
+    onStepChange?: (details: TourStepChangeDetails) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onStatusChange?: (details: TourStatusChangeDetails) => void;
+    keyboardNavigation?: boolean;
+    closeOnEscape?: boolean;
+    closeOnInteractOutside?: boolean;
+    spotlightOffset?: number;
+    spotlightRadius?: number;
+    id?: string;
+    children?: React.ReactNode;
+};
+export type TourBackdropProps = React.ComponentPropsWithoutRef<"div"> & {
+    portalContainerName?: string;
+    className?: string;
+};
+export type TourSpotlightProps = TourBackdropProps;
+export type TourPositionerProps = React.ComponentPropsWithoutRef<"div"> & {
+    side?: AnchorSide;
+    align?: AnchorAlignment;
+    placement?: TourFloatingPlacement;
+    portalContainerName?: string;
+    className?: string;
+};
+export type TourContentProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type TourArrowProps = Omit<CaretProps, "location">;
+export type TourCloseTriggerProps = Omit<React.ComponentPropsWithoutRef<"button">, "aria-labelledby"> & {
+    icon?: NonNullable<ButtonVisual>;
+    className?: string;
+};
+export type TourTitleProps = React.ComponentPropsWithoutRef<"h2"> & {
+    className?: string;
+};
+export type TourDescriptionProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type TourProgressTextProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type TourControlProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type TourActionsProps = {
+    children: (actions: TourAction[]) => React.ReactNode;
+};
+export type TourActionTriggerProps = Omit<React.ComponentPropsWithoutRef<"button">, "action" | "children"> & {
+    action: TourAction;
+    variant?: ButtonVariant;
+    children?: React.ReactNode;
+    className?: string;
+};

package/build/components/tour/TourActionTrigger.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "children" | "action"> & {
+    action: import("./Tour.types").TourAction;
+    variant?: import("..").ButtonVariant;
+    children?: React.ReactNode;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;