@cognitiv/components-web 1.0.5 → 1.1.0

package/dist/components/text/styles.js

@@ -0,0 +1,28 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const textVariants = tv({
+  base: ["transition-colors duration-200"],
+  defaultVariants: {
+    size: "base",
+    variant: "default"
+  },
+  variants: {
+    size: {
+      base: "text-base",
+      lg: "text-lg",
+      sm: "text-sm",
+      xl: "text-xl",
+      xs: "text-xs"
+    },
+    variant: {
+      danger: "text-danger",
+      default: "text-foreground",
+      muted: "text-muted",
+      success: "text-success",
+      warning: "text-warning"
+    }
+  }
+});
+
+export { textVariants };

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

@@ -0,0 +1,8 @@
+import type { TextVariants } from "./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 { Text } from 'react-aria-components';
+import { textVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+
+const TextRoot = ({
+  children,
+  className,
+  size,
+  variant,
+  ...rest
+}) => {
+  const styles = textVariants({
+    className,
+    size,
+    variant
+  });
+  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 "./styles";
+export type { TextAreaVariants } from "./styles";

package/dist/components/textarea/index.js

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

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

@@ -0,0 +1,30 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const textAreaVariants: import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+    variant: {
+        primary: string;
+        secondary: string;
+    };
+}, undefined, "textarea", {
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+    variant: {
+        primary: string;
+        secondary: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+    variant: {
+        primary: string;
+        secondary: string;
+    };
+}, undefined, "textarea", unknown, unknown, undefined>>;
+export type TextAreaVariants = VariantProps<typeof textAreaVariants>;

package/dist/components/textarea/styles.js

@@ -0,0 +1,22 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const textAreaVariants = tv({
+  base: "textarea",
+  defaultVariants: {
+    fullWidth: false,
+    variant: "primary"
+  },
+  variants: {
+    fullWidth: {
+      false: "",
+      true: "textarea--full-width"
+    },
+    variant: {
+      primary: "textarea--primary",
+      secondary: "textarea--secondary"
+    }
+  }
+});
+
+export { textAreaVariants };

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

@@ -0,0 +1,8 @@
+import type { TextAreaVariants } from "./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 { useContext } from 'react';
+import { TextArea } from 'react-aria-components';
+import { textAreaVariants } from './styles.js';
+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 "./styles";
+export type { TextFieldVariants } from "./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 './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const TextField = Object.assign(TextFieldRoot, {
+  Root: TextFieldRoot
+});
+
+export { TextField, TextFieldRoot };

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

@@ -0,0 +1,18 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const textFieldVariants: import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+}, undefined, "textfield", {
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+}, undefined, "textfield", unknown, unknown, undefined>>;
+export type TextFieldVariants = VariantProps<typeof textFieldVariants>;

package/dist/components/textfield/styles.js

@@ -0,0 +1,17 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const textFieldVariants = tv({
+  base: "textfield",
+  defaultVariants: {
+    fullWidth: false
+  },
+  variants: {
+    fullWidth: {
+      false: "",
+      true: "textfield--full-width"
+    }
+  }
+});
+
+export { textFieldVariants };

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

@@ -0,0 +1,18 @@
+import type { TextFieldVariants } from "./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 React__default, { createContext } from 'react';
+import { TextField } from 'react-aria-components';
+import { composeTwRenderProps } from '../../utils/compose.js';
+import { textFieldVariants } from './styles.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 & {
+    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;
+    Prefix: ({ children, className, ...props }: import("../date-input-group").DateInputGroupPrefixProps) => import("react/jsx-runtime").JSX.Element;
+    Root: typeof TimeFieldRoot;
+    Segment: ({ className, segment, ...props }: import("../date-input-group").DateInputGroupSegmentProps) => 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 "./styles";
+export type { TimeFieldVariants } from "./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 './styles.js';
+import { DateInputGroupSuffix, DateInputGroupSegment, DateInputGroupPrefix, DateInputGroupInputContainer, DateInputGroupInput, DateInputGroupRoot } from '../date-input-group/date-input-group.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const TimeField = Object.assign(TimeFieldRoot, {
+  Group: DateInputGroupRoot,
+  Input: DateInputGroupInput,
+  InputContainer: DateInputGroupInputContainer,
+  Prefix: DateInputGroupPrefix,
+  Root: TimeFieldRoot,
+  Segment: DateInputGroupSegment,
+  Suffix: DateInputGroupSuffix
+});
+
+export { TimeField, TimeFieldRoot };

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

@@ -0,0 +1,18 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const timeFieldVariants: import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+}, undefined, "time-field", {
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+}, undefined, "time-field", unknown, unknown, undefined>>;
+export type TimeFieldVariants = VariantProps<typeof timeFieldVariants>;

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

@@ -0,0 +1,17 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const timeFieldVariants = tv({
+  base: "time-field",
+  defaultVariants: {
+    fullWidth: false
+  },
+  variants: {
+    fullWidth: {
+      false: "",
+      true: "time-field--full-width"
+    }
+  }
+});
+
+export { timeFieldVariants };

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

@@ -0,0 +1,9 @@
+import type { TimeFieldVariants } from "./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 React__default from 'react';
+import { TimeField } from 'react-aria-components';
+import { dataAttr } from '../../utils/assertion.js';
+import { composeTwRenderProps } from '../../utils/compose.js';
+import { timeFieldVariants } from './styles.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;
+} & {
+    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;
+    };
+    Content: ({ children, className, ...rest }: import("./toast").ToastContentProps) => import("react/jsx-runtime").JSX.Element;
+    Description: {
+        ({ children, className, ...rest }: import("./toast").ToastDescriptionProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Indicator: {
+        ({ children, className, variant, ...rest }: import("./toast").ToastIndicatorProps): 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;
+    };
+    Queue: typeof ToastQueue;
+    Title: {
+        ({ children, className, ...rest }: import("./toast").ToastTitleProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    toast: {
+        (message: import("react").ReactNode, options?: import("./toast-queue").CognitivToastOptions): string;
+        success(message: import("react").ReactNode, options?: Omit<import("./toast-queue").CognitivToastOptions, "variant">): string;
+        danger(message: import("react").ReactNode, options?: Omit<import("./toast-queue").CognitivToastOptions, "variant">): string;
+        info(message: import("react").ReactNode, options?: Omit<import("./toast-queue").CognitivToastOptions, "variant">): string;
+        warning(message: import("react").ReactNode, options?: Omit<import("./toast-queue").CognitivToastOptions, "variant">): string;
+        promise<T>(promise: Promise<T> | (() => Promise<T>), options: import("./toast-queue").ToastPromiseOptions<T>): string;
+        getQueue(): import("react-stately").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").CognitivToastOptions, "variant">) => string;
+        danger: (message: import("react").ReactNode, options?: Omit<import("./toast-queue").CognitivToastOptions, "variant">) => string;
+        info: (message: import("react").ReactNode, options?: Omit<import("./toast-queue").CognitivToastOptions, "variant">) => string;
+        warning: (message: import("react").ReactNode, options?: Omit<import("./toast-queue").CognitivToastOptions, "variant">) => string;
+        promise: <T>(promise: Promise<T> | (() => Promise<T>), options: import("./toast-queue").ToastPromiseOptions<T>) => string;
+        getQueue: () => ReturnType<() => import("react-stately").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 "./styles";
+export type { ToastVariants } from "./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, ToastTitle, ToastProvider, ToastIndicator, ToastDescription, ToastContent, ToastCloseButton, ToastActionButton } from './toast.js';
+import { toast, ToastQueue } from './toast-queue.js';
+export { toastQueue } from './toast-queue.js';
+export { toastVariants } from './styles.js';
+export { DEFAULT_GAP, DEFAULT_MAX_VISIBLE_TOAST, DEFAULT_TOAST_TIMEOUT } from './constants.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Toast = Object.assign(Toast$1, {
+  ActionButton: ToastActionButton,
+  CloseButton: ToastCloseButton,
+  Content: ToastContent,
+  Description: ToastDescription,
+  Indicator: ToastIndicator,
+  Provider: ToastProvider,
+  Queue: ToastQueue,
+  Title: ToastTitle,
+  toast
+});
+
+export { Toast, ToastActionButton, ToastCloseButton, ToastContent, ToastDescription, ToastIndicator, ToastProvider, ToastQueue, ToastTitle, toast };