@masaraxui/react 1.0.0

package/dist/components/tag/tag.js

@@ -0,0 +1,85 @@
+"use client";
+import { tagVariants } from '@masaraxui/styles';
+import { useContext, useMemo, Children, createContext } from 'react';
+import { Tag } from 'react-aria-components';
+import { pickChildren } from '../../utils/children.js';
+import { composeTwRenderProps } from '../../utils/compose.js';
+import { CloseButton } from '../close-button/index.js';
+import '../tag-group/index.js';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { TagGroupContext } from '../tag-group/tag-group.js';
+
+const TagContext = /*#__PURE__*/createContext({});
+
+/* -------------------------------------------------------------------------------------------------
+ * Tag Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const TagRoot = ({
+  children,
+  className,
+  ...restProps
+}) => {
+  const {
+    size,
+    variant
+  } = useContext(TagGroupContext);
+  const slots = useMemo(() => tagVariants({
+    size,
+    variant
+  }), [size, variant]);
+  const textValue = useMemo(() => {
+    if (typeof children === "string") {
+      return children;
+    }
+    if (typeof children === "object") {
+      return Children.toArray(children).filter(node => typeof node === "string").at(0);
+    }
+    return undefined;
+  }, [children]);
+
+  // Extract custom RemoveButton from children if present
+  const [childrenWithoutRemoveButton, removeButtonChildren] = useMemo(() => {
+    if (typeof children === "function") {
+      return [children, undefined];
+    }
+    return pickChildren(children, TagRemoveButton);
+  }, [children]);
+  return /*#__PURE__*/jsx(Tag, {
+    className: composeTwRenderProps(className, slots.base()),
+    "data-slot": "tag",
+    textValue: textValue,
+    ...restProps,
+    children: renderProps => /*#__PURE__*/jsx(TagContext, {
+      value: {
+        slots
+      },
+      children: typeof children === "function" ? children(renderProps) : /*#__PURE__*/jsxs(Fragment, {
+        children: [childrenWithoutRemoveButton, !!renderProps.allowsRemoving && (removeButtonChildren && removeButtonChildren.length > 0 ? removeButtonChildren : /*#__PURE__*/jsx(TagRemoveButton, {}))]
+      })
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Tag Remove Button
+ * -----------------------------------------------------------------------------------------------*/
+
+const TagRemoveButton = ({
+  children,
+  className,
+  ...restProps
+}) => {
+  const {
+    slots
+  } = useContext(TagContext);
+  return /*#__PURE__*/jsx(CloseButton, {
+    className: composeTwRenderProps(className, slots?.removeButton()),
+    "data-slot": "tag-remove-button",
+    slot: "remove",
+    ...restProps,
+    children: children
+  });
+};
+
+export { TagRemoveButton, TagRoot };

package/dist/components/tag-group/index.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentProps } from "react";
+import { TagGroupContext, TagGroupList, TagGroupRoot } from "./tag-group";
+export declare const TagGroup: (({ children, className, size, variant, ...restProps }: import("./tag-group").TagGroupRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, className, size, variant, ...restProps }: import("./tag-group").TagGroupRootProps) => import("react/jsx-runtime").JSX.Element;
+    List: <T extends object>({ children, className, ...restProps }: import("./tag-group").TagGroupListProps<T>) => import("react/jsx-runtime").JSX.Element;
+};
+export type TagGroup = {
+    Props: ComponentProps<typeof TagGroupRoot>;
+    RootProps: ComponentProps<typeof TagGroupRoot>;
+    ListProps: ComponentProps<typeof TagGroupList>;
+};
+export { TagGroupRoot, TagGroupList, TagGroupContext };
+export type { TagGroupRootProps, TagGroupRootProps as TagGroupProps, TagGroupListProps, } from "./tag-group";
+export { tagGroupVariants } from "@masaraxui/styles";
+export type { TagGroupVariants } from "@masaraxui/styles";

package/dist/components/tag-group/index.js

@@ -0,0 +1,14 @@
+"use strict";
+import { TagGroupRoot, TagGroupList } from './tag-group.js';
+export { TagGroupContext } from './tag-group.js';
+export { tagGroupVariants } from '@masaraxui/styles';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const TagGroup = Object.assign(TagGroupRoot, {
+  Root: TagGroupRoot,
+  List: TagGroupList
+});
+
+export { TagGroup, TagGroupList, TagGroupRoot };

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

@@ -0,0 +1,20 @@
+import type { TagVariants } from "../tag";
+import type { ComponentPropsWithRef } from "react";
+import { tagGroupVariants } from "@masaraxui/styles";
+import React from "react";
+import { TagGroup as TagGroupPrimitive, TagList as TagListPrimitive } from "react-aria-components";
+type TagGroupContext = {
+    slots?: ReturnType<typeof tagGroupVariants>;
+    size?: TagVariants["size"];
+    variant?: TagVariants["variant"];
+};
+declare const TagGroupContext: React.Context<TagGroupContext>;
+type TagGroupRootProps = ComponentPropsWithRef<typeof TagGroupPrimitive> & {
+    size?: TagVariants["size"];
+    variant?: TagVariants["variant"];
+};
+declare const TagGroupRoot: ({ children, className, size, variant, ...restProps }: TagGroupRootProps) => import("react/jsx-runtime").JSX.Element;
+type TagGroupListProps<T extends object> = ComponentPropsWithRef<typeof TagListPrimitive<T>> & {};
+declare const TagGroupList: <T extends object>({ children, className, ...restProps }: TagGroupListProps<T>) => import("react/jsx-runtime").JSX.Element;
+export { TagGroupRoot, TagGroupList, TagGroupContext };
+export type { TagGroupRootProps, TagGroupListProps };

package/dist/components/tag-group/tag-group.js

@@ -0,0 +1,59 @@
+"use client";
+import { tagGroupVariants } from '@masaraxui/styles';
+import { useMemo, createContext, useContext } from 'react';
+import { TagGroup, TagList } from 'react-aria-components';
+import { composeTwRenderProps } from '../../utils/compose.js';
+import { jsx } from 'react/jsx-runtime';
+
+const TagGroupContext = /*#__PURE__*/createContext({});
+
+/* -------------------------------------------------------------------------------------------------
+ * TagGroup Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const TagGroupRoot = ({
+  children,
+  className,
+  size,
+  variant,
+  ...restProps
+}) => {
+  const slots = useMemo(() => tagGroupVariants(), []);
+  return /*#__PURE__*/jsx(TagGroupContext, {
+    value: {
+      slots,
+      size,
+      variant
+    },
+    children: /*#__PURE__*/jsx(TagGroup, {
+      className: slots.base({
+        className
+      }),
+      "data-slot": "tag-group",
+      ...restProps,
+      children: children
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * TagGroup List
+ * -----------------------------------------------------------------------------------------------*/
+
+const TagGroupList = ({
+  children,
+  className,
+  ...restProps
+}) => {
+  const {
+    slots
+  } = useContext(TagGroupContext);
+  return /*#__PURE__*/jsx(TagList, {
+    className: composeTwRenderProps(className, slots?.list()),
+    "data-slot": "tag-group-list",
+    ...restProps,
+    children: children
+  });
+};
+
+export { TagGroupContext, TagGroupList, TagGroupRoot };

package/dist/components/text/index.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentProps } from "react";
+import { TextRoot } from "./text";
+export declare const Text: (({ children, className, size, variant, ...rest }: import("./text").TextRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, className, size, variant, ...rest }: import("./text").TextRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type Text = {
+    Props: ComponentProps<typeof TextRoot>;
+    RootProps: ComponentProps<typeof TextRoot>;
+};
+export { TextRoot };
+export type { TextRootProps, TextRootProps as TextProps } from "./text";
+export { textVariants } from "@masaraxui/styles";
+export type { TextVariants } from "@masaraxui/styles";

package/dist/components/text/index.js

@@ -0,0 +1,12 @@
+"use strict";
+import { TextRoot } from './text.js';
+export { textVariants } from '@masaraxui/styles';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Text = Object.assign(TextRoot, {
+  Root: TextRoot
+});
+
+export { Text, TextRoot };

package/dist/components/text/text.d.ts

@@ -0,0 +1,8 @@
+import type { TextVariants } from "@masaraxui/styles";
+import type { ComponentPropsWithRef } from "react";
+import { Text as TextPrimitive } from "react-aria-components";
+interface TextRootProps extends ComponentPropsWithRef<typeof TextPrimitive>, TextVariants {
+}
+declare const TextRoot: ({ children, className, size, variant, ...rest }: TextRootProps) => import("react/jsx-runtime").JSX.Element;
+export { TextRoot };
+export type { TextRootProps };

package/dist/components/text/text.js

@@ -0,0 +1,25 @@
+"use client";
+import { textVariants } from '@masaraxui/styles';
+import { Text } from 'react-aria-components';
+import { jsx } from 'react/jsx-runtime';
+
+const TextRoot = ({
+  children,
+  className,
+  size,
+  variant,
+  ...rest
+}) => {
+  const styles = textVariants({
+    size,
+    variant,
+    className
+  });
+  return /*#__PURE__*/jsx(Text, {
+    className: styles,
+    ...rest,
+    children: children
+  });
+};
+
+export { TextRoot };

package/dist/components/textarea/index.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentProps } from "react";
+import { TextAreaRoot } from "./textarea";
+export declare const TextArea: (({ className, fullWidth, variant, ...rest }: import("./textarea").TextAreaRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ className, fullWidth, variant, ...rest }: import("./textarea").TextAreaRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type TextArea = {
+    Props: ComponentProps<typeof TextAreaRoot>;
+    RootProps: ComponentProps<typeof TextAreaRoot>;
+};
+export { TextAreaRoot };
+export type { TextAreaRootProps, TextAreaRootProps as TextAreaProps } from "./textarea";
+export { textAreaVariants } from "@masaraxui/styles";
+export type { TextAreaVariants } from "@masaraxui/styles";

package/dist/components/textarea/index.js

@@ -0,0 +1,12 @@
+"use strict";
+import { TextAreaRoot } from './textarea.js';
+export { textAreaVariants } from '@masaraxui/styles';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const TextArea = Object.assign(TextAreaRoot, {
+  Root: TextAreaRoot
+});
+
+export { TextArea, TextAreaRoot };

package/dist/components/textarea/textarea.d.ts

@@ -0,0 +1,8 @@
+import type { TextAreaVariants } from "@masaraxui/styles";
+import type { ComponentPropsWithRef } from "react";
+import { TextArea as TextAreaPrimitive } from "react-aria-components";
+interface TextAreaRootProps extends ComponentPropsWithRef<typeof TextAreaPrimitive>, TextAreaVariants {
+}
+declare const TextAreaRoot: ({ className, fullWidth, variant, ...rest }: TextAreaRootProps) => import("react/jsx-runtime").JSX.Element;
+export { TextAreaRoot };
+export type { TextAreaRootProps };

package/dist/components/textarea/textarea.js

@@ -0,0 +1,27 @@
+"use client";
+import { textAreaVariants } from '@masaraxui/styles';
+import { useContext } from 'react';
+import { TextArea } from 'react-aria-components';
+import { jsx } from 'react/jsx-runtime';
+import { TextFieldContext } from '../textfield/textfield.js';
+import { composeTwRenderProps } from '../../utils/compose.js';
+
+const TextAreaRoot = ({
+  className,
+  fullWidth,
+  variant,
+  ...rest
+}) => {
+  const textFieldContext = useContext(TextFieldContext);
+  const resolvedVariant = variant ?? textFieldContext?.variant;
+  return /*#__PURE__*/jsx(TextArea, {
+    "data-slot": "textarea",
+    className: composeTwRenderProps(className, textAreaVariants({
+      fullWidth,
+      variant: resolvedVariant
+    })),
+    ...rest
+  });
+};
+
+export { TextAreaRoot };

package/dist/components/textfield/index.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentProps } from "react";
+import { TextFieldRoot } from "./textfield";
+export declare const TextField: (({ children, className, fullWidth, variant, ...props }: import("./textfield").TextFieldRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, className, fullWidth, variant, ...props }: import("./textfield").TextFieldRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type TextField = {
+    Props: ComponentProps<typeof TextFieldRoot>;
+    RootProps: ComponentProps<typeof TextFieldRoot>;
+};
+export { TextFieldRoot };
+export type { TextFieldRootProps, TextFieldRootProps as TextFieldProps } from "./textfield";
+export { TextFieldContext } from "./textfield";
+export { textFieldVariants } from "@masaraxui/styles";
+export type { TextFieldVariants } from "@masaraxui/styles";

package/dist/components/textfield/index.js

@@ -0,0 +1,13 @@
+"use strict";
+import { TextFieldRoot } from './textfield.js';
+export { TextFieldContext } from './textfield.js';
+export { textFieldVariants } from '@masaraxui/styles';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const TextField = Object.assign(TextFieldRoot, {
+  Root: TextFieldRoot
+});
+
+export { TextField, TextFieldRoot };

package/dist/components/textfield/textfield.d.ts

@@ -0,0 +1,18 @@
+import type { TextFieldVariants } from "@masaraxui/styles";
+import type { ComponentPropsWithRef } from "react";
+import React from "react";
+import { TextField as TextFieldPrimitive } from "react-aria-components";
+type TextFieldContext = {
+    variant?: "primary" | "secondary";
+};
+declare const TextFieldContext: React.Context<TextFieldContext>;
+interface TextFieldRootProps extends ComponentPropsWithRef<typeof TextFieldPrimitive>, TextFieldVariants {
+    /**
+     * The variant of the text field.
+     * @default "primary"
+     */
+    variant?: "primary" | "secondary";
+}
+declare const TextFieldRoot: ({ children, className, fullWidth, variant, ...props }: TextFieldRootProps) => import("react/jsx-runtime").JSX.Element;
+export { TextFieldRoot, TextFieldContext };
+export type { TextFieldRootProps };

package/dist/components/textfield/textfield.js

@@ -0,0 +1,39 @@
+"use client";
+import { textFieldVariants } from '@masaraxui/styles';
+import React__default, { createContext } from 'react';
+import { TextField } from 'react-aria-components';
+import { composeTwRenderProps } from '../../utils/compose.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+const TextFieldContext = /*#__PURE__*/createContext({});
+
+/* -------------------------------------------------------------------------------------------------
+ * TextField Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const TextFieldRoot = ({
+  children,
+  className,
+  fullWidth,
+  variant,
+  ...props
+}) => {
+  const styles = React__default.useMemo(() => textFieldVariants({
+    fullWidth
+  }), [fullWidth]);
+  return /*#__PURE__*/jsx(TextField, {
+    "data-slot": "textfield",
+    ...props,
+    className: composeTwRenderProps(className, styles),
+    children: values => /*#__PURE__*/jsx(TextFieldContext, {
+      value: {
+        variant
+      },
+      children: /*#__PURE__*/jsx(Fragment, {
+        children: typeof children === "function" ? children(values) : children
+      })
+    })
+  });
+};
+
+export { TextFieldContext, TextFieldRoot };

package/dist/components/time-field/index.d.ts

@@ -0,0 +1,26 @@
+import type { ComponentProps } from "react";
+import { DateInputGroupInput, DateInputGroupInputContainer, DateInputGroupPrefix, DateInputGroupRoot, DateInputGroupSegment, DateInputGroupSuffix } from "../date-input-group";
+import { TimeFieldRoot } from "./time-field";
+export declare const TimeField: typeof TimeFieldRoot & {
+    Root: typeof TimeFieldRoot;
+    Group: ({ children, className, fullWidth, variant, ...props }: import("../date-input-group").DateInputGroupRootProps) => import("react/jsx-runtime").JSX.Element;
+    Input: ({ className, ...props }: import("../date-input-group").DateInputGroupInputProps) => import("react/jsx-runtime").JSX.Element;
+    InputContainer: ({ children, className, ...props }: import("../date-input-group").DateInputGroupInputContainerProps) => import("react/jsx-runtime").JSX.Element;
+    Segment: ({ className, segment, ...props }: import("../date-input-group").DateInputGroupSegmentProps) => import("react/jsx-runtime").JSX.Element;
+    Prefix: ({ children, className, ...props }: import("../date-input-group").DateInputGroupPrefixProps) => import("react/jsx-runtime").JSX.Element;
+    Suffix: ({ children, className, ...props }: import("../date-input-group").DateInputGroupSuffixProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type TimeField = {
+    Props: ComponentProps<typeof TimeFieldRoot>;
+    RootProps: ComponentProps<typeof TimeFieldRoot>;
+    GroupProps: ComponentProps<typeof DateInputGroupRoot>;
+    InputProps: ComponentProps<typeof DateInputGroupInput>;
+    InputContainerProps: ComponentProps<typeof DateInputGroupInputContainer>;
+    SegmentProps: ComponentProps<typeof DateInputGroupSegment>;
+    PrefixProps: ComponentProps<typeof DateInputGroupPrefix>;
+    SuffixProps: ComponentProps<typeof DateInputGroupSuffix>;
+};
+export { TimeFieldRoot };
+export type { TimeFieldRootProps, TimeFieldRootProps as TimeFieldProps } from "./time-field";
+export { timeFieldVariants } from "@masaraxui/styles";
+export type { TimeFieldVariants } from "@masaraxui/styles";

package/dist/components/time-field/index.js

@@ -0,0 +1,20 @@
+"use strict";
+import '../date-input-group/index.js';
+import { TimeFieldRoot } from './time-field.js';
+export { timeFieldVariants } from '@masaraxui/styles';
+import { DateInputGroupSuffix, DateInputGroupPrefix, DateInputGroupSegment, DateInputGroupInputContainer, DateInputGroupInput, DateInputGroupRoot } from '../date-input-group/date-input-group.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const TimeField = Object.assign(TimeFieldRoot, {
+  Root: TimeFieldRoot,
+  Group: DateInputGroupRoot,
+  Input: DateInputGroupInput,
+  InputContainer: DateInputGroupInputContainer,
+  Segment: DateInputGroupSegment,
+  Prefix: DateInputGroupPrefix,
+  Suffix: DateInputGroupSuffix
+});
+
+export { TimeField, TimeFieldRoot };

package/dist/components/time-field/time-field.d.ts

@@ -0,0 +1,9 @@
+import type { TimeFieldVariants } from "@masaraxui/styles";
+import type { ComponentPropsWithRef } from "react";
+import type { TimeValue } from "react-aria-components";
+import { TimeField as TimeFieldPrimitive } from "react-aria-components";
+interface TimeFieldRootProps<T extends TimeValue> extends ComponentPropsWithRef<typeof TimeFieldPrimitive<T>>, TimeFieldVariants {
+}
+declare function TimeFieldRoot<T extends TimeValue>({ children, className, fullWidth, ...props }: TimeFieldRootProps<T>): import("react/jsx-runtime").JSX.Element;
+export { TimeFieldRoot };
+export type { TimeFieldRootProps };

package/dist/components/time-field/time-field.js

@@ -0,0 +1,29 @@
+"use client";
+import { timeFieldVariants } from '@masaraxui/styles';
+import React__default from 'react';
+import { TimeField } from 'react-aria-components';
+import { dataAttr } from '../../utils/assertion.js';
+import { composeTwRenderProps } from '../../utils/compose.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+function TimeFieldRoot({
+  children,
+  className,
+  fullWidth,
+  ...props
+}) {
+  const styles = React__default.useMemo(() => timeFieldVariants({
+    fullWidth
+  }), [fullWidth]);
+  return /*#__PURE__*/jsx(TimeField, {
+    "data-required": dataAttr(props.isRequired),
+    "data-slot": "time-field",
+    ...props,
+    className: composeTwRenderProps(className, styles),
+    children: values => /*#__PURE__*/jsx(Fragment, {
+      children: typeof children === "function" ? children(values) : children
+    })
+  });
+}
+
+export { TimeFieldRoot };

package/dist/components/toast/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_GAP = 12;
+export declare const DEFAULT_MAX_VISIBLE_TOAST = 3;
+export declare const DEFAULT_RAC_MAX_VISIBLE_TOAST: number;
+export declare const DEFAULT_SCALE_FACTOR = 0.05;
+export declare const DEFAULT_TOAST_WIDTH = 460;
+export declare const DEFAULT_TOAST_TIMEOUT = 4000;

package/dist/components/toast/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+// Default gap between toasts
+const DEFAULT_GAP = 12;
+// The default maximum number of visible toasts (visual only).
+const DEFAULT_MAX_VISIBLE_TOAST = 3;
+// The maximum number of toasts to render in the RAC queue.
+const DEFAULT_RAC_MAX_VISIBLE_TOAST = Number.MAX_SAFE_INTEGER;
+// The default scale factor for toasts.
+const DEFAULT_SCALE_FACTOR = 0.05;
+// The default width of the toast.
+const DEFAULT_TOAST_WIDTH = 460;
+// The default timeout for toasts in milliseconds (matches sonner's default).
+const DEFAULT_TOAST_TIMEOUT = 4000;
+
+export { DEFAULT_GAP, DEFAULT_MAX_VISIBLE_TOAST, DEFAULT_RAC_MAX_VISIBLE_TOAST, DEFAULT_SCALE_FACTOR, DEFAULT_TOAST_TIMEOUT, DEFAULT_TOAST_WIDTH };

package/dist/components/toast/index.d.ts

@@ -0,0 +1,75 @@
+import type { ComponentProps } from "react";
+import { ToastActionButton, ToastCloseButton, ToastContent, ToastDescription, ToastIndicator, ToastProvider, Toast as ToastRoot, ToastTitle } from "./toast";
+import { ToastQueue, toast, toastQueue } from "./toast-queue";
+export declare const Toast: {
+    <T extends object = import("./toast-queue").ToastContentValue>({ children, className, placement, scaleFactor, toast, variant, ...rest }: import("./toast").ToastProps<T>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+} & {
+    Provider: {
+        <T extends object = import("./toast-queue").ToastContentValue>({ children, className, gap, maxVisibleToasts, placement, queue: queueProp, scaleFactor, width, ...rest }: import("./toast").ToastProviderProps<T>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Content: ({ children, className, ...rest }: import("./toast").ToastContentProps) => import("react/jsx-runtime").JSX.Element;
+    Indicator: {
+        ({ children, className, variant, ...rest }: import("./toast").ToastIndicatorProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Title: {
+        ({ children, className, ...rest }: import("./toast").ToastTitleProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Description: {
+        ({ children, className, ...rest }: import("./toast").ToastDescriptionProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    ActionButton: {
+        ({ children, className, ...rest }: import("./toast").ToastActionButtonProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    CloseButton: {
+        ({ className, ...rest }: import("./toast").ToastCloseButtonProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Queue: typeof ToastQueue;
+    toast: {
+        (message: import("react").ReactNode, options?: import("./toast-queue").MasaraxUIToastOptions): string;
+        success(message: import("react").ReactNode, options?: Omit<import("./toast-queue").MasaraxUIToastOptions, "variant">): string;
+        danger(message: import("react").ReactNode, options?: Omit<import("./toast-queue").MasaraxUIToastOptions, "variant">): string;
+        info(message: import("react").ReactNode, options?: Omit<import("./toast-queue").MasaraxUIToastOptions, "variant">): string;
+        warning(message: import("react").ReactNode, options?: Omit<import("./toast-queue").MasaraxUIToastOptions, "variant">): string;
+        promise<T>(promise: Promise<T> | (() => Promise<T>), options: import("./toast-queue").ToastPromiseOptions<T>): string;
+        getQueue(): import("react-aria-components").UNSTABLE_ToastQueue<import("./toast-queue").ToastContentValue>;
+        close(key: string): void;
+        pauseAll(): void;
+        resumeAll(): void;
+        clear(): void;
+    } & {
+        success: (message: import("react").ReactNode, options?: Omit<import("./toast-queue").MasaraxUIToastOptions, "variant">) => string;
+        danger: (message: import("react").ReactNode, options?: Omit<import("./toast-queue").MasaraxUIToastOptions, "variant">) => string;
+        info: (message: import("react").ReactNode, options?: Omit<import("./toast-queue").MasaraxUIToastOptions, "variant">) => string;
+        warning: (message: import("react").ReactNode, options?: Omit<import("./toast-queue").MasaraxUIToastOptions, "variant">) => string;
+        promise: <T>(promise: Promise<T> | (() => Promise<T>), options: import("./toast-queue").ToastPromiseOptions<T>) => string;
+        getQueue: () => ReturnType<() => import("react-aria-components").UNSTABLE_ToastQueue<import("./toast-queue").ToastContentValue>>;
+        close: (key: string) => void;
+        pauseAll: () => void;
+        resumeAll: () => void;
+        clear: () => void;
+    };
+};
+export type Toast = {
+    Props: ComponentProps<typeof ToastRoot>;
+    ProviderProps: ComponentProps<typeof ToastProvider>;
+    ContentProps: ComponentProps<typeof ToastContent>;
+    IndicatorProps: ComponentProps<typeof ToastIndicator>;
+    TitleProps: ComponentProps<typeof ToastTitle>;
+    DescriptionProps: ComponentProps<typeof ToastDescription>;
+    ActionProps: ComponentProps<typeof ToastActionButton>;
+    CloseButtonProps: ComponentProps<typeof ToastCloseButton>;
+};
+export { ToastProvider, ToastContent, ToastIndicator, ToastTitle, ToastDescription, ToastActionButton, ToastCloseButton, };
+export type { ToastCloseButtonProps, ToastProviderProps, ToastContentProps, ToastDescriptionProps, ToastIndicatorProps, ToastProps, ToastTitleProps, } from "./toast";
+export { toastVariants } from "@masaraxui/styles";
+export type { ToastVariants } from "@masaraxui/styles";
+export { ToastQueue, toast, toastQueue };
+export { DEFAULT_MAX_VISIBLE_TOAST, DEFAULT_GAP, DEFAULT_TOAST_TIMEOUT } from "./constants";
+export type { ToastQueueOptions, ToastContentValue } from "./toast-queue";

package/dist/components/toast/index.js

@@ -0,0 +1,23 @@
+"use strict";
+import { Toast as Toast$1, ToastCloseButton, ToastActionButton, ToastDescription, ToastTitle, ToastIndicator, ToastContent, ToastProvider } from './toast.js';
+import { toast, ToastQueue } from './toast-queue.js';
+export { toastQueue } from './toast-queue.js';
+export { toastVariants } from '@masaraxui/styles';
+export { DEFAULT_GAP, DEFAULT_MAX_VISIBLE_TOAST, DEFAULT_TOAST_TIMEOUT } from './constants.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Toast = Object.assign(Toast$1, {
+  Provider: ToastProvider,
+  Content: ToastContent,
+  Indicator: ToastIndicator,
+  Title: ToastTitle,
+  Description: ToastDescription,
+  ActionButton: ToastActionButton,
+  CloseButton: ToastCloseButton,
+  Queue: ToastQueue,
+  toast
+});
+
+export { Toast, ToastActionButton, ToastCloseButton, ToastContent, ToastDescription, ToastIndicator, ToastProvider, ToastQueue, ToastTitle, toast };