grassroot
Install

DocsAPI referenceHeadlesstoast

toast headless API

The core connector and vanilla mount are always visible. Use the framework choice to inspect native composition, props, outputs, context and hooks for the selected adapter.

Machine APIPlatform contract

@grassroot/ui-headless-core/toast

Core connector and vanilla API

32 exports
View source packages/ui-headless/core/src/toast/index.ts

connectToast

function
DeclarationView source
connectToastts
declare function connectToast<T = unknown>(service: ToastService, scope: PartScope, options?: ToastConnectOptions<T>): ToastApi<T>;
Name
Kind
Type
Requirement
service
parameter
ToastService
required
scope
parameter
PartScope
required
options
parameter
ToastConnectOptions<T>
optional
return
return value
ToastApi<T>
n/a
Name
service
Kind
parameter
Type
ToastService
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
options
Kind
parameter
Type
ToastConnectOptions<T>
Requirement
optional
Name
return
Kind
return value
Type
ToastApi<T>
Requirement
n/a

createToastScheduledRunner

function
DeclarationView source
createToastScheduledRunnerts
declare function createToastScheduledRunner(scheduler: Scheduler, next: RunCommand<ToastCommand, ToastEvent> | undefined, onFired?: () => void): RunCommand<ToastCommand, ToastEvent>;
Name
Kind
Type
Requirement
scheduler
parameter
Scheduler
required
next
parameter
RunCommand<ToastCommand, ToastEvent> | undefined
required
onFired
parameter
() => void
optional
return
return value
RunCommand<ToastCommand, ToastEvent>
n/a
Name
scheduler
Kind
parameter
Type
Scheduler
Requirement
required
Name
next
Kind
parameter
Type
RunCommand<ToastCommand, ToastEvent> | undefined
Requirement
required
Name
onFired
Kind
parameter
Type
() => void
Requirement
optional
Name
return
Kind
return value
Type
RunCommand<ToastCommand, ToastEvent>
Requirement
n/a

createToastSidecar

function
DeclarationView source
createToastSidecarts
declare function createToastSidecar<T = unknown>(): ToastSidecar<T>;
Name
Kind
Type
Requirement
return
return value
ToastSidecar<T>
n/a
Name
return
Kind
return value
Type
ToastSidecar<T>
Requirement
n/a

mountToast

function
DeclarationView source
mountToastts
declare function mountToast(container: HTMLElement, options?: MountToastOptions): ToastMount;
Name
Kind
Type
Requirement
container
parameter
HTMLElement
required
options
parameter
MountToastOptions
optional
return
return value
ToastMount
n/a
Name
container
Kind
parameter
Type
HTMLElement
Requirement
required
Name
options
Kind
parameter
Type
MountToastOptions
Requirement
optional
Name
return
Kind
return value
Type
ToastMount
Requirement
n/a

MountToastOptions

interface
DeclarationView source
MountToastOptionsts
interface MountToastOptions {
  readonly scheduler?: Scheduler;
  readonly nextId?: () => string;
}
Name
Kind
Type
Requirement
nextId
property
() => string
optional
scheduler
property
Scheduler
optional
Name
nextId
Kind
property
Type
() => string
Requirement
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional

nextToastPublicId

function
DeclarationView source
nextToastPublicIdts
declare function nextToastPublicId(): string;
Name
Kind
Type
Requirement
return
return value
string
n/a
Name
return
Kind
return value
Type
string
Requirement
n/a

pruneToastSidecar

function
DeclarationView source
pruneToastSidecarts
declare function pruneToastSidecar<T>(sidecar: ToastSidecar<T>, service: ToastService): void;
Name
Kind
Type
Requirement
sidecar
parameter
ToastSidecar<T>
required
service
parameter
ToastService
required
return
return value
void
n/a
Name
sidecar
Kind
parameter
Type
ToastSidecar<T>
Requirement
required
Name
service
Kind
parameter
Type
ToastService
Requirement
required
Name
return
Kind
return value
Type
void
Requirement
n/a

runToastCommand

function
DeclarationView source
runToastCommandts
declare function runToastCommand(_command: ToastCommand): void;
Name
Kind
Type
Requirement
_command
parameter
ToastCommand
required
return
return value
void
n/a
Name
_command
Kind
parameter
Type
ToastCommand
Requirement
required
Name
return
Kind
return value
Type
void
Requirement
n/a

TOAST_DEFAULT_DURATION

value
DeclarationView source
TOAST_DEFAULT_DURATIONts
export declare const TOAST_DEFAULT_DURATION: 4000;

TOAST_DEFAULT_VARIANT

value
DeclarationView source
TOAST_DEFAULT_VARIANTts
export declare const TOAST_DEFAULT_VARIANT: "info";

TOAST_DISMISS_KEY_PREFIX

value
DeclarationView source
TOAST_DISMISS_KEY_PREFIXts
export declare const TOAST_DISMISS_KEY_PREFIX: "toast.dismiss.";

ToastAddOptions

type
DeclarationView source
ToastAddOptionsts
type ToastAddOptions<T = unknown> = {
  readonly id?: string;
  readonly title: T;
  readonly description?: T;
  readonly variant?: ToastVariant;
  readonly duration?: number;
};
Name
Kind
Type
Requirement
description
property
T
optional
duration
property
number
optional
id
property
string
optional
title
property
T
required
variant
property
ToastVariant
optional
Name
description
Kind
property
Type
T
Requirement
optional
Name
duration
Kind
property
Type
number
Requirement
optional
Name
id
Kind
property
Type
string
Requirement
optional
Name
title
Kind
property
Type
T
Requirement
required
Name
variant
Kind
property
Type
ToastVariant
Requirement
optional

toastAnatomy

value
DeclarationView source
toastAnatomyts
export declare const toastAnatomy: {
  readonly scope: "toast";
  readonly parts: readonly ["viewport", "item", "toast", "indicator", "body", "title", "description", "close"];
};
Name
Kind
Type
Requirement
parts
property
readonly ["viewport", "item", "toast", "indicator", "body", "title", "description", "close"]
required
scope
property
"toast"
required
Name
parts
Kind
property
Type
readonly ["viewport", "item", "toast", "indicator", "body", "title", "description", "close"]
Requirement
required
Name
scope
Kind
property
Type
"toast"
Requirement
required

ToastApi

interface
DeclarationView source
ToastApits
interface ToastApi<T = unknown> {
  viewportProps(): PartProps;
  itemProps(instanceKey: string): PartProps;
  toastProps(instanceKey: string): PartProps;
  indicatorProps(instanceKey: string): PartProps;
  bodyProps(instanceKey: string): PartProps;
  titleProps(instanceKey: string): PartProps;
  descriptionProps(instanceKey: string): PartProps;
  closeProps(instanceKey: string): PartProps;
  toast(options: ToastAddOptions<T>): string;
  dismiss(id: string): void;
  readonly items: readonly ToastRecord[];
  readonly toasts: readonly ToastView<T>[];
}
Name
Kind
Type
Requirement
bodyProps
method
(instanceKey: string) => PartProps
required
closeProps
method
(instanceKey: string) => PartProps
required
descriptionProps
method
(instanceKey: string) => PartProps
required
dismiss
method
(id: string) => void
required
indicatorProps
method
(instanceKey: string) => PartProps
required
itemProps
method
(instanceKey: string) => PartProps
required
items
property
readonly ToastRecord[]
required
titleProps
method
(instanceKey: string) => PartProps
required
toast
method
(options: ToastAddOptions<T>) => string
required
toastProps
method
(instanceKey: string) => PartProps
required
toasts
property
readonly ToastView<T>[]
required
viewportProps
method
() => PartProps
required
Name
bodyProps
Kind
method
Type
(instanceKey: string) => PartProps
Requirement
required
Name
closeProps
Kind
method
Type
(instanceKey: string) => PartProps
Requirement
required
Name
descriptionProps
Kind
method
Type
(instanceKey: string) => PartProps
Requirement
required
Name
dismiss
Kind
method
Type
(id: string) => void
Requirement
required
Name
indicatorProps
Kind
method
Type
(instanceKey: string) => PartProps
Requirement
required
Name
itemProps
Kind
method
Type
(instanceKey: string) => PartProps
Requirement
required
Name
items
Kind
property
Type
readonly ToastRecord[]
Requirement
required
Name
titleProps
Kind
method
Type
(instanceKey: string) => PartProps
Requirement
required
Name
toast
Kind
method
Type
(options: ToastAddOptions<T>) => string
Requirement
required
Name
toastProps
Kind
method
Type
(instanceKey: string) => PartProps
Requirement
required
Name
toasts
Kind
property
Type
readonly ToastView<T>[]
Requirement
required
Name
viewportProps
Kind
method
Type
() => PartProps
Requirement
required

ToastCommand

type
DeclarationView source
ToastCommandts
type ToastCommand = ScheduleCommand<ToastEvent> | CancelCommand;

ToastConnectOptions

interface
DeclarationView source
ToastConnectOptionsts
interface ToastConnectOptions<T = unknown> {
  readonly sidecar?: ToastSidecar<T>;
  readonly nextId?: () => string;
}
Name
Kind
Type
Requirement
nextId
property
() => string
optional
sidecar
property
ToastSidecar<T>
optional
Name
nextId
Kind
property
Type
() => string
Requirement
optional
Name
sidecar
Kind
property
Type
ToastSidecar<T>
Requirement
optional

ToastContent

type
DeclarationView source
ToastContentts
type ToastContent<T = unknown> = {
  readonly title: T;
  readonly description?: T;
};
Name
Kind
Type
Requirement
description
property
T
optional
title
property
T
required
Name
description
Kind
property
Type
T
Requirement
optional
Name
title
Kind
property
Type
T
Requirement
required

ToastContext

type
DeclarationView source
ToastContextts
type ToastContext = {
  readonly nextKey: number;
  readonly toasts: readonly ToastRecord[];
};
Name
Kind
Type
Requirement
nextKey
property
number
required
toasts
property
readonly ToastRecord[]
required
Name
nextKey
Kind
property
Type
number
Requirement
required
Name
toasts
Kind
property
Type
readonly ToastRecord[]
Requirement
required

toastDismissKey

function
DeclarationView source
toastDismissKeyts
declare function toastDismissKey(instanceKey: string): string;
Name
Kind
Type
Requirement
instanceKey
parameter
string
required
return
return value
string
n/a
Name
instanceKey
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
string
Requirement
n/a

ToastEvent

type
DeclarationView source
ToastEventts
type ToastEvent = {
  readonly type: "ADD";
  readonly id: string;
  readonly variant?: ToastVariant;
  readonly duration?: number;
} | {
  readonly type: "DISMISS";
  readonly id: string;
} | {
  readonly type: "DISMISS_INSTANCE";
  readonly instanceKey: string;
};

ToastInput

type

No S12 bindings — the queue is service-owned.

DeclarationView source
ToastInputts
type ToastInput = {};

toastMachine

value
DeclarationView source
toastMachinets
export declare const toastMachine: ToastMachine;

ToastMount

interface
DeclarationView source
ToastMountts
interface ToastMount {
  readonly service: ToastService;
  readonly connector: ToastApi<string>;
  readonly viewport: HTMLElement;
  toast(options: ToastAddOptions<string>): string;
  dismiss(id: string): void;
  destroy(): void;
}
Name
Kind
Type
Requirement
connector
property
ToastApi<string>
required
destroy
method
() => void
required
dismiss
method
(id: string) => void
required
service
property
ToastService
required
toast
method
(options: ToastAddOptions<string>) => string
required
viewport
property
HTMLElement
required
Name
connector
Kind
property
Type
ToastApi<string>
Requirement
required
Name
destroy
Kind
method
Type
() => void
Requirement
required
Name
dismiss
Kind
method
Type
(id: string) => void
Requirement
required
Name
service
Kind
property
Type
ToastService
Requirement
required
Name
toast
Kind
method
Type
(options: ToastAddOptions<string>) => string
Requirement
required
Name
viewport
Kind
property
Type
HTMLElement
Requirement
required

ToastPart

type
DeclarationView source
ToastPartts
type ToastPart = (typeof toastAnatomy.parts)[number];

ToastRecord

type
DeclarationView source
ToastRecordts
type ToastRecord = {
  readonly instanceKey: string;
  readonly id: string;
  readonly variant: ToastVariant;
  readonly duration: number;
};
Name
Kind
Type
Requirement
duration
property
number
required
id
property
string
required
instanceKey
property
string
required
variant
property
ToastVariant
required
Name
duration
Kind
property
Type
number
Requirement
required
Name
id
Kind
property
Type
string
Requirement
required
Name
instanceKey
Kind
property
Type
string
Requirement
required
Name
variant
Kind
property
Type
ToastVariant
Requirement
required

toastSelectors

value
DeclarationView source
toastSelectorsts
export declare const toastSelectors: {
  toasts: (snapshot: ToastSnapshot) => readonly ToastRecord[];
  nextKey: (snapshot: ToastSnapshot) => number;
  ids: (snapshot: ToastSnapshot) => string[];
  instanceKeys: (snapshot: ToastSnapshot) => string[];
  empty: (snapshot: ToastSnapshot) => boolean;
};
Name
Kind
Type
Requirement
empty
property
(snapshot: ToastSnapshot) => boolean
required
ids
property
(snapshot: ToastSnapshot) => string[]
required
instanceKeys
property
(snapshot: ToastSnapshot) => string[]
required
nextKey
property
(snapshot: ToastSnapshot) => number
required
toasts
property
(snapshot: ToastSnapshot) => readonly ToastRecord[]
required
Name
empty
Kind
property
Type
(snapshot: ToastSnapshot) => boolean
Requirement
required
Name
ids
Kind
property
Type
(snapshot: ToastSnapshot) => string[]
Requirement
required
Name
instanceKeys
Kind
property
Type
(snapshot: ToastSnapshot) => string[]
Requirement
required
Name
nextKey
Kind
property
Type
(snapshot: ToastSnapshot) => number
Requirement
required
Name
toasts
Kind
property
Type
(snapshot: ToastSnapshot) => readonly ToastRecord[]
Requirement
required

ToastService

type
DeclarationView source
ToastServicets
type ToastService = Service<ToastInput, ToastStateValue, ToastContext, ToastEvent, ToastCommand>;

ToastSidecar

interface
DeclarationView source
ToastSidecarts
interface ToastSidecar<T = unknown> {
  set(instanceKey: string, content: ToastContent<T>): void;
  get(instanceKey: string): ToastContent<T> | undefined;
  delete(instanceKey: string): void;
  clear(): void;
  prune(liveKeys: readonly string[]): void;
}
Name
Kind
Type
Requirement
clear
method
() => void
required
delete
method
(instanceKey: string) => void
required
get
method
(instanceKey: string) => ToastContent<T> | undefined
required
prune
method
(liveKeys: readonly string[]) => void
required
set
method
(instanceKey: string, content: ToastContent<T>) => void
required
Name
clear
Kind
method
Type
() => void
Requirement
required
Name
delete
Kind
method
Type
(instanceKey: string) => void
Requirement
required
Name
get
Kind
method
Type
(instanceKey: string) => ToastContent<T> | undefined
Requirement
required
Name
prune
Kind
method
Type
(liveKeys: readonly string[]) => void
Requirement
required
Name
set
Kind
method
Type
(instanceKey: string, content: ToastContent<T>) => void
Requirement
required

ToastSnapshot

type
DeclarationView source
ToastSnapshotts
type ToastSnapshot = Snapshot<ToastStateValue, ToastContext>;

ToastStateValue

type
DeclarationView source
ToastStateValuets
type ToastStateValue = "idle" | "queued";

ToastVariant

type
DeclarationView source
ToastVariantts
type ToastVariant = "info" | "success" | "warning" | "error";

ToastView

type
DeclarationView source
ToastViewts
type ToastView<T = unknown> = ToastRecord & ToastContent<T>;

Framework adapters

Each panel keeps its adapter's public vocabulary. React compound exports, Vue composables, standalone Angular declarations, Svelte components, and Solid hooks stay native to their framework.

React example follows below.

React imports

@grassroot/ui-headless-react/toastts
import { Body, Close, Description, Indicator, Item, Root, Title, Toast } from "@grassroot/ui-headless-react/toast"; // +2 more exports

Vue imports

@grassroot/ui-headless-vue/toastts
<script setup lang="ts">
import { ToastBody, ToastClose, ToastDescription, ToastIndicator, ToastItem, ToastRoot, ToastTitle, ToastToast } from "@grassroot/ui-headless-vue/toast"; // +1 more exports
</script>

Angular imports

@grassroot/ui-headless-angular/toastts
import { Component } from "@angular/core";
import { GR_TOAST_DECLARATIONS } from "@grassroot/ui-headless-angular/toast";
 
@Component({ standalone: true, imports: [GR_TOAST_DECLARATIONS], template: `<!-- compose the toast parts here -->` })
export class Example {}

Svelte imports

@grassroot/ui-headless-svelte/toastts
<script lang="ts">
  import { ToastBody, ToastClose, ToastDescription, ToastIndicator, ToastItem, ToastRoot, ToastTitle, ToastToast } from "@grassroot/ui-headless-svelte/toast"; // +1 more exports
</script>

Solid imports

@grassroot/ui-headless-solid/toastts
import { ToastBody, ToastClose, ToastDescription, ToastIndicator, ToastItem, ToastRoot, ToastTitle, ToastToast } from "@grassroot/ui-headless-solid/toast"; // +1 more exports

@grassroot/ui-headless-react/toast

React adapter

27 exports
View source packages/ui-headless/react/src/toast/index.ts

Body

value
DeclarationView source
Bodyts
export declare const Body: import("react").ForwardRefExoticComponent<ToastBodyProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Close

value
DeclarationView source
Closets
export declare const Close: import("react").ForwardRefExoticComponent<ToastCloseProps & import("react").RefAttributes<HTMLButtonElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Description

value
DeclarationView source
Descriptionts
export declare const Description: import("react").ForwardRefExoticComponent<ToastDescriptionProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Indicator

value
DeclarationView source
Indicatorts
export declare const Indicator: import("react").ForwardRefExoticComponent<ToastIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Item

value
DeclarationView source
Itemts
export declare const Item: import("react").ForwardRefExoticComponent<ToastItemProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Root

function
DeclarationView source
Rootts
declare function Root(props: ToastRootProps): import("react").JSX.Element;
Name
Kind
Type
Requirement
props
parameter
ToastRootProps
required
return
return value
import("react").JSX.Element
n/a
Name
props
Kind
parameter
Type
ToastRootProps
Requirement
required
Name
return
Kind
return value
Type
import("react").JSX.Element
Requirement
n/a

Title

value
DeclarationView source
Titlets
export declare const Title: import("react").ForwardRefExoticComponent<ToastTitleProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Toast

value
DeclarationView source
Toastts
export declare const Toast: import("react").ForwardRefExoticComponent<ToastToastProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

ToastApi

interface
DeclarationView source
ToastApits
interface ToastApi {
  readonly toasts: readonly ToastView[];
  toast(options: ToastAddOptions): string;
  dismiss(id: string): void;
}
Name
Kind
Type
Requirement
dismiss
method
(id: string) => void
required
toast
method
(options: ToastAddOptions) => string
required
toasts
property
readonly ToastView[]
required
Name
dismiss
Kind
method
Type
(id: string) => void
Requirement
required
Name
toast
Kind
method
Type
(options: ToastAddOptions) => string
Requirement
required
Name
toasts
Kind
property
Type
readonly ToastView[]
Requirement
required

ToastBodyProps

interface
DeclarationView source
ToastBodyPropsts
interface ToastBodyProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly instanceKey: string;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
instanceKey
property
string
required
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
instanceKey
Kind
property
Type
string
Requirement
required

ToastCloseProps

interface
DeclarationView source
ToastClosePropsts
interface ToastCloseProps extends Omit<ComponentPropsWithoutRef<"button">, "type"> {
  readonly asChild?: boolean;
  readonly instanceKey: string;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
instanceKey
property
string
required
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
instanceKey
Kind
property
Type
string
Requirement
required

ToastContext

value
DeclarationView source
ToastContextts
export declare const ToastContext: import("react").Context<ToastContextValue | null>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

ToastContextValue

interface
DeclarationView source
ToastContextValuets
interface ToastContextValue {
  readonly service: ToastService;
  readonly connector: ToastApi;
  readonly scope: PartScope;
}
Name
Kind
Type
Requirement
connector
property
ToastApi
required
scope
property
PartScope
required
service
property
ToastService
required
Name
connector
Kind
property
Type
ToastApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
ToastService
Requirement
required

ToastDescriptionProps

interface
DeclarationView source
ToastDescriptionPropsts
interface ToastDescriptionProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly instanceKey: string;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
instanceKey
property
string
required
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
instanceKey
Kind
property
Type
string
Requirement
required

ToastIndicatorProps

interface
DeclarationView source
ToastIndicatorPropsts
interface ToastIndicatorProps extends ComponentPropsWithoutRef<"span"> {
  readonly asChild?: boolean;
  readonly instanceKey: string;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
instanceKey
property
string
required
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
instanceKey
Kind
property
Type
string
Requirement
required

ToastItemProps

interface
DeclarationView source
ToastItemPropsts
interface ToastItemProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly instanceKey: string;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
instanceKey
property
string
required
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
instanceKey
Kind
property
Type
string
Requirement
required

ToastProvider

value
DeclarationView source
ToastProviderts
export declare const ToastProvider: {
  Root: typeof Root;
  Viewport: import("react").ForwardRefExoticComponent<ToastViewportProps & import("react").RefAttributes<HTMLDivElement>>;
  Item: import("react").ForwardRefExoticComponent<ToastItemProps & import("react").RefAttributes<HTMLDivElement>>;
  Toast: import("react").ForwardRefExoticComponent<ToastToastProps & import("react").RefAttributes<HTMLDivElement>>;
  Indicator: import("react").ForwardRefExoticComponent<ToastIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;
  Body: import("react").ForwardRefExoticComponent<ToastBodyProps & import("react").RefAttributes<HTMLDivElement>>;
  Title: import("react").ForwardRefExoticComponent<ToastTitleProps & import("react").RefAttributes<HTMLDivElement>>;
  Description: import("react").ForwardRefExoticComponent<ToastDescriptionProps & import("react").RefAttributes<HTMLDivElement>>;
  Close: import("react").ForwardRefExoticComponent<ToastCloseProps & import("react").RefAttributes<HTMLButtonElement>>;
};
Name
Kind
Type
Requirement
Body
property
import("react").ForwardRefExoticComponent<ToastBodyProps & import("react").RefAttributes<HTMLDivElement>>
required
Close
property
import("react").ForwardRefExoticComponent<ToastCloseProps & import("react").RefAttributes<HTMLButtonElement>>
required
Description
property
import("react").ForwardRefExoticComponent<ToastDescriptionProps & import("react").RefAttributes<HTMLDivElement>>
required
Indicator
property
import("react").ForwardRefExoticComponent<ToastIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>
required
Item
property
import("react").ForwardRefExoticComponent<ToastItemProps & import("react").RefAttributes<HTMLDivElement>>
required
Root
property
typeof Root
required
Title
property
import("react").ForwardRefExoticComponent<ToastTitleProps & import("react").RefAttributes<HTMLDivElement>>
required
Toast
property
import("react").ForwardRefExoticComponent<ToastToastProps & import("react").RefAttributes<HTMLDivElement>>
required
Viewport
property
import("react").ForwardRefExoticComponent<ToastViewportProps & import("react").RefAttributes<HTMLDivElement>>
required
Name
Body
Kind
property
Type
import("react").ForwardRefExoticComponent<ToastBodyProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Close
Kind
property
Type
import("react").ForwardRefExoticComponent<ToastCloseProps & import("react").RefAttributes<HTMLButtonElement>>
Requirement
required
Name
Description
Kind
property
Type
import("react").ForwardRefExoticComponent<ToastDescriptionProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Indicator
Kind
property
Type
import("react").ForwardRefExoticComponent<ToastIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>
Requirement
required
Name
Item
Kind
property
Type
import("react").ForwardRefExoticComponent<ToastItemProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Root
Kind
property
Type
typeof Root
Requirement
required
Name
Title
Kind
property
Type
import("react").ForwardRefExoticComponent<ToastTitleProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Toast
Kind
property
Type
import("react").ForwardRefExoticComponent<ToastToastProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Viewport
Kind
property
Type
import("react").ForwardRefExoticComponent<ToastViewportProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required

ToastRootProps

interface
DeclarationView source
ToastRootPropsts
interface ToastRootProps {
  readonly scheduler?: UseToastOptions["scheduler"];
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
children
property
ReactNode
optional
scheduler
property
UseToastOptions["scheduler"]
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
scheduler
Kind
property
Type
UseToastOptions["scheduler"]
Requirement
optional

ToastTitleProps

interface
DeclarationView source
ToastTitlePropsts
interface ToastTitleProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly instanceKey: string;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
instanceKey
property
string
required
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
instanceKey
Kind
property
Type
string
Requirement
required

ToastToastProps

interface
DeclarationView source
ToastToastPropsts
interface ToastToastProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly instanceKey: string;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
instanceKey
property
string
required
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
instanceKey
Kind
property
Type
string
Requirement
required

ToastViewportProps

interface
DeclarationView source
ToastViewportPropsts
interface ToastViewportProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional

useToast

function
DeclarationView source
useToastts
declare function useToast(): ToastApi;
Name
Kind
Type
Requirement
return
return value
ToastApi
n/a
Name
return
Kind
return value
Type
ToastApi
Requirement
n/a

useToastContext

function
DeclarationView source
useToastContextts
declare function useToastContext(partName: string): ToastContextValue;
Name
Kind
Type
Requirement
partName
parameter
string
required
return
return value
ToastContextValue
n/a
Name
partName
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
ToastContextValue
Requirement
n/a

UseToastOptions

interface
DeclarationView source
UseToastOptionsts
interface UseToastOptions {
  readonly scheduler?: Scheduler;
}
Name
Kind
Type
Requirement
scheduler
property
Scheduler
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional

useToastStore

function
DeclarationView source
useToastStorets
declare function useToastStore(options?: UseToastOptions): UseToastStoreResult;
Name
Kind
Type
Requirement
options
parameter
UseToastOptions
optional
return
return value
UseToastStoreResult
n/a
Name
options
Kind
parameter
Type
UseToastOptions
Requirement
optional
Name
return
Kind
return value
Type
UseToastStoreResult
Requirement
n/a

UseToastStoreResult

interface
DeclarationView source
UseToastStoreResultts
interface UseToastStoreResult {
  readonly service: ToastService;
  readonly connector: ToastApi;
  readonly scope: PartScope;
  readonly snapshot: ToastSnapshot;
}
Name
Kind
Type
Requirement
connector
property
ToastApi
required
scope
property
PartScope
required
service
property
ToastService
required
snapshot
property
ToastSnapshot
required
Name
connector
Kind
property
Type
ToastApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
ToastService
Requirement
required
Name
snapshot
Kind
property
Type
ToastSnapshot
Requirement
required

Viewport

value
DeclarationView source
Viewportts
export declare const Viewport: import("react").ForwardRefExoticComponent<ToastViewportProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

@grassroot/ui-headless-vue/toast

Vue adapter

17 exports
View source packages/ui-headless/vue/src/toast/index.ts

ToastApi

interface
DeclarationView source
ToastApits
interface ToastApi {
  readonly toasts: ComputedRef<readonly ToastView[]>;
  toast(options: ToastAddOptions): string;
  dismiss(id: string): void;
}
Name
Kind
Type
Requirement
dismiss
method
(id: string) => void
required
toast
method
(options: ToastAddOptions) => string
required
toasts
property
ComputedRef<readonly ToastView[]>
required
Name
dismiss
Kind
method
Type
(id: string) => void
Requirement
required
Name
toast
Kind
method
Type
(options: ToastAddOptions) => string
Requirement
required
Name
toasts
Kind
property
Type
ComputedRef<readonly ToastView[]>
Requirement
required

ToastBody

value
DeclarationView source
ToastBodyts
export declare const ToastBody: import("vue").DefineComponent<{
  asChild: boolean;
  instanceKey?: string | undefined;
}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
  asChild: boolean;
  instanceKey?: string | undefined;
}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ToastClose

value
DeclarationView source
ToastClosets
export declare const ToastClose: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  instanceKey: {
    type: StringConstructor;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  instanceKey: {
    type: StringConstructor;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ToastContextKey

value
DeclarationView source
ToastContextKeyts
export declare const ToastContextKey: InjectionKey<ToastContextValue>;

ToastContextValue

interface
DeclarationView source
ToastContextValuets
interface ToastContextValue {
  readonly service: ToastService;
  readonly connector: ToastApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<ToastSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
ToastApi
required
scope
property
PartScope
required
service
property
ToastService
required
snapshot
property
ShallowRef<ToastSnapshot>
required
Name
connector
Kind
property
Type
ToastApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
ToastService
Requirement
required
Name
snapshot
Kind
property
Type
ShallowRef<ToastSnapshot>
Requirement
required

ToastDescription

value
DeclarationView source
ToastDescriptionts
export declare const ToastDescription: import("vue").DefineComponent<{
  asChild: boolean;
  instanceKey?: string | undefined;
}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
  asChild: boolean;
  instanceKey?: string | undefined;
}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ToastIndicator

value
DeclarationView source
ToastIndicatorts
export declare const ToastIndicator: import("vue").DefineComponent<{
  asChild: boolean;
  instanceKey?: string | undefined;
}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
  asChild: boolean;
  instanceKey?: string | undefined;
}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ToastItem

value
DeclarationView source
ToastItemts
export declare const ToastItem: import("vue").DefineComponent<{
  asChild: boolean;
  instanceKey?: string | undefined;
}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
  asChild: boolean;
  instanceKey?: string | undefined;
}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ToastRoot

value
DeclarationView source
ToastRootts
export declare const ToastRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  scheduler: {
    type: PropType<UseToastOptions["scheduler"]>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  scheduler: {
    type: PropType<UseToastOptions["scheduler"]>;
    default: undefined;
  };
}>> & Readonly<{}>, {
  scheduler: import("@grassroot/statechart/scheduler").Scheduler | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ToastTitle

value
DeclarationView source
ToastTitlets
export declare const ToastTitle: import("vue").DefineComponent<{
  asChild: boolean;
  instanceKey?: string | undefined;
}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
  asChild: boolean;
  instanceKey?: string | undefined;
}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ToastToast

value
DeclarationView source
ToastToastts
export declare const ToastToast: import("vue").DefineComponent<{
  asChild: boolean;
  instanceKey?: string | undefined;
}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
  asChild: boolean;
  instanceKey?: string | undefined;
}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ToastViewport

value
DeclarationView source
ToastViewportts
export declare const ToastViewport: import("vue").DefineComponent<{
  asChild: boolean;
  instanceKey?: string | undefined;
}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
  asChild: boolean;
  instanceKey?: string | undefined;
}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

useToast

function
DeclarationView source
useToastts
declare function useToast(): ToastApi;
Name
Kind
Type
Requirement
return
return value
ToastApi
n/a
Name
return
Kind
return value
Type
ToastApi
Requirement
n/a

useToastContext

function
DeclarationView source
useToastContextts
declare function useToastContext(partName: string): ToastContextValue;
Name
Kind
Type
Requirement
partName
parameter
string
required
return
return value
ToastContextValue
n/a
Name
partName
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
ToastContextValue
Requirement
n/a

UseToastOptions

interface
DeclarationView source
UseToastOptionsts
interface UseToastOptions {
  readonly scheduler?: Scheduler;
}
Name
Kind
Type
Requirement
scheduler
property
Scheduler
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional

useToastStore

function
DeclarationView source
useToastStorets
declare function useToastStore(options?: UseToastOptions): UseToastStoreResult;
Name
Kind
Type
Requirement
options
parameter
UseToastOptions
optional
return
return value
UseToastStoreResult
n/a
Name
options
Kind
parameter
Type
UseToastOptions
Requirement
optional
Name
return
Kind
return value
Type
UseToastStoreResult
Requirement
n/a

UseToastStoreResult

interface
DeclarationView source
UseToastStoreResultts
interface UseToastStoreResult {
  readonly service: ToastService;
  readonly connector: ToastApi$1;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<ToastSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
ToastApi$1
required
scope
property
PartScope
required
service
property
ToastService
required
snapshot
property
ShallowRef<ToastSnapshot>
required
Name
connector
Kind
property
Type
ToastApi$1
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
ToastService
Requirement
required
Name
snapshot
Kind
property
Type
ShallowRef<ToastSnapshot>
Requirement
required

@grassroot/ui-headless-angular/toast

Angular adapter

18 exports
View source packages/ui-headless/angular/src/toast/index.ts

applyProps

function

Applies a connector prop bag to a persistent Angular DOM element.

DeclarationView source
applyPropsts
export declare function applyProps(el: Element, props: PartProps, listeners: Map<string, EventListener>): void;
Name
Kind
Type
Requirement
el
parameter
Element
required
props
parameter
PartProps
required
listeners
parameter
Map<string, EventListener>
required
return
return value
void
n/a
Name
el
Kind
parameter
Type
Element
Requirement
required
Name
props
Kind
parameter
Type
PartProps
Requirement
required
Name
listeners
Kind
parameter
Type
Map<string, EventListener>
Requirement
required
Name
return
Kind
return value
Type
void
Requirement
n/a

createReentrantSafeTick

function

One re-entrancy policy for every Angular store's zoneless commit nudge.

DeclarationView source
createReentrantSafeTickts
export declare function createReentrantSafeTick(appRef: ApplicationRef): () => void;
Name
Kind
Type
Requirement
appRef
parameter
ApplicationRef
required
return
return value
() => void
n/a
Name
appRef
Kind
parameter
Type
ApplicationRef
Requirement
required
Name
return
Kind
return value
Type
() => void
Requirement
n/a

createToastStore

function
DeclarationView source
createToastStorets
export declare function createToastStore(_initialInput?: ToastInput, options?: CreateToastStoreOptions): ToastStore;
Name
Kind
Type
Requirement
_initialInput
parameter
ToastInput
optional
options
parameter
CreateToastStoreOptions
optional
return
return value
ToastStore
n/a
Name
_initialInput
Kind
parameter
Type
ToastInput
Requirement
optional
Name
options
Kind
parameter
Type
CreateToastStoreOptions
Requirement
optional
Name
return
Kind
return value
Type
ToastStore
Requirement
n/a

CreateToastStoreOptions

interface
DeclarationView source
CreateToastStoreOptionsts
export interface CreateToastStoreOptions {
    readonly onCommit?: () => void;
    readonly scheduler?: Scheduler;
}
Name
Kind
Type
Requirement
onCommit
property
() => void
optional
scheduler
property
Scheduler
optional
Name
onCommit
Kind
property
Type
() => void
Requirement
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional

GR_TOAST_DECLARATIONS

value
DeclarationView source
GR_TOAST_DECLARATIONSts
export declare const GR_TOAST_DECLARATIONS: readonly [typeof GrToastRoot, typeof GrToastViewport, typeof GrToastItem, typeof GrToastToast, typeof GrToastIndicator, typeof GrToastBody, typeof GrToastTitle, typeof GrToastDescription, typeof GrToastClose];

GrToastBody

class
DeclarationView source
GrToastBodyts
export declare class GrToastBody implements OnDestroy {
    readonly instanceKey: import("@angular/core").InputSignal<string>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registered;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrToastBody, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrToastBody, "[grToastBody]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
instanceKey
property
import("@angular/core").InputSignal<string>
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrToastBody, "[grToastBody]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrToastBody, never>
required
registered
property
any
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
instanceKey
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrToastBody, "[grToastBody]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrToastBody, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrToastClose

class
DeclarationView source
GrToastClosets
export declare class GrToastClose implements OnDestroy {
    readonly instanceKey: import("@angular/core").InputSignal<string>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registered;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrToastClose, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrToastClose, "[grToastClose]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
instanceKey
property
import("@angular/core").InputSignal<string>
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrToastClose, "[grToastClose]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrToastClose, never>
required
registered
property
any
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
instanceKey
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrToastClose, "[grToastClose]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrToastClose, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrToastDescription

class
DeclarationView source
GrToastDescriptionts
export declare class GrToastDescription implements OnDestroy {
    readonly instanceKey: import("@angular/core").InputSignal<string>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registered;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrToastDescription, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrToastDescription, "[grToastDescription]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
instanceKey
property
import("@angular/core").InputSignal<string>
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrToastDescription, "[grToastDescription]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrToastDescription, never>
required
registered
property
any
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
instanceKey
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrToastDescription, "[grToastDescription]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrToastDescription, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrToastIndicator

class
DeclarationView source
GrToastIndicatorts
export declare class GrToastIndicator implements OnDestroy {
    readonly instanceKey: import("@angular/core").InputSignal<string>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registered;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrToastIndicator, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrToastIndicator, "[grToastIndicator]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
instanceKey
property
import("@angular/core").InputSignal<string>
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrToastIndicator, "[grToastIndicator]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrToastIndicator, never>
required
registered
property
any
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
instanceKey
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrToastIndicator, "[grToastIndicator]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrToastIndicator, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrToastItem

class
DeclarationView source
GrToastItemts
export declare class GrToastItem implements OnDestroy {
    readonly instanceKey: import("@angular/core").InputSignal<string>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registered;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrToastItem, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrToastItem, "[grToastItem]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
instanceKey
property
import("@angular/core").InputSignal<string>
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrToastItem, "[grToastItem]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrToastItem, never>
required
registered
property
any
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
instanceKey
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrToastItem, "[grToastItem]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrToastItem, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrToastRoot

class
DeclarationView source
GrToastRootts
export declare class GrToastRoot implements OnDestroy {
    readonly store: ToastStore;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrToastRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrToastRoot, "gr-toast-root", never, {}, {}, never, ["*"], true, never>;
}
Name
Kind
Type
Requirement
ngOnDestroy
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrToastRoot, "gr-toast-root", never, {}, {}, never, ["*"], true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrToastRoot, never>
required
store
property
ToastStore
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrToastRoot, "gr-toast-root", never, {}, {}, never, ["*"], true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrToastRoot, never>
Requirement
required
Name
store
Kind
property
Type
ToastStore
Requirement
required

GrToastTitle

class
DeclarationView source
GrToastTitlets
export declare class GrToastTitle implements OnDestroy {
    readonly instanceKey: import("@angular/core").InputSignal<string>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registered;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrToastTitle, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrToastTitle, "[grToastTitle]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
instanceKey
property
import("@angular/core").InputSignal<string>
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrToastTitle, "[grToastTitle]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrToastTitle, never>
required
registered
property
any
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
instanceKey
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrToastTitle, "[grToastTitle]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrToastTitle, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrToastToast

class
DeclarationView source
GrToastToastts
export declare class GrToastToast implements OnDestroy {
    readonly instanceKey: import("@angular/core").InputSignal<string>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registered;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrToastToast, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrToastToast, "[grToastToast]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
instanceKey
property
import("@angular/core").InputSignal<string>
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrToastToast, "[grToastToast]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrToastToast, never>
required
registered
property
any
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
instanceKey
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrToastToast, "[grToastToast]", never, { "instanceKey": { "alias": "instanceKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrToastToast, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrToastViewport

class
DeclarationView source
GrToastViewportts
export declare class GrToastViewport implements OnDestroy {
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrToastViewport, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrToastViewport, "[grToastViewport]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrToastViewport, "[grToastViewport]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrToastViewport, never>
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrToastViewport, "[grToastViewport]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrToastViewport, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

provideToastStore

function
DeclarationView source
provideToastStorets
export declare function provideToastStore(): Provider;
Name
Kind
Type
Requirement
return
return value
Provider
n/a
Name
return
Kind
return value
Type
Provider
Requirement
n/a

TOAST_SCHEDULER

value
DeclarationView source
TOAST_SCHEDULERts
export declare const TOAST_SCHEDULER: InjectionToken<Scheduler>;

TOAST_STORE

value
DeclarationView source
TOAST_STOREts
export declare const TOAST_STORE: InjectionToken<ToastStore>;

ToastStore

interface
DeclarationView source
ToastStorets
export interface ToastStore {
    readonly service: ToastService;
    readonly connector: ToastApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: ToastInput): void;
}
Name
Kind
Type
Requirement
connector
property
ToastApi
required
scope
property
PartScope
required
service
property
ToastService
required
start
method
() => void
required
stop
method
() => void
required
sync
method
(input: ToastInput) => void
required
version
property
WritableSignal<number>
required
Name
connector
Kind
property
Type
ToastApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
ToastService
Requirement
required
Name
start
Kind
method
Type
() => void
Requirement
required
Name
stop
Kind
method
Type
() => void
Requirement
required
Name
sync
Kind
method
Type
(input: ToastInput) => void
Requirement
required
Name
version
Kind
property
Type
WritableSignal<number>
Requirement
required

@grassroot/ui-headless-svelte/toast

Svelte adapter

18 exports
View source packages/ui-headless/svelte/src/toast/index.ts

createToast

function
DeclarationView source
createToastts
export declare function createToast(options?: UseToastOptions): UseToastResult;
Name
Kind
Type
Requirement
options
parameter
UseToastOptions
optional
return
return value
UseToastResult
n/a
Name
options
Kind
parameter
Type
UseToastOptions
Requirement
optional
Name
return
Kind
return value
Type
UseToastResult
Requirement
n/a

portal

function
DeclarationView source
portalts
export declare function portal(node: Element, target?: () => Element): {
    destroy: () => void;
};
Name
Kind
Type
Requirement
node
parameter
Element
required
target
parameter
() => Element
optional
return
return value
{ destroy: () => void; }
n/a
Name
node
Kind
parameter
Type
Element
Requirement
required
Name
target
Kind
parameter
Type
() => Element
Requirement
optional
Name
return
Kind
return value
Type
{ destroy: () => void; }
Requirement
n/a

provideToastContext

function
DeclarationView source
provideToastContextts
export declare function provideToastContext(value: ToastContextValue): void;
Name
Kind
Type
Requirement
value
parameter
ToastContextValue
required
return
return value
void
n/a
Name
value
Kind
parameter
Type
ToastContextValue
Requirement
required
Name
return
Kind
return value
Type
void
Requirement
n/a

splitProps

function

Split the core prop bag, then apply Svelte-specific style/event handling.

DeclarationView source
splitPropsts
export declare function splitProps(props: PartProps): SplitProps;
Name
Kind
Type
Requirement
props
parameter
PartProps
required
return
return value
SplitProps
n/a
Name
props
Kind
parameter
Type
PartProps
Requirement
required
Name
return
Kind
return value
Type
SplitProps
Requirement
n/a

ToastBody

value
DeclarationView source
ToastBodyts
export declare const ToastBody: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

ToastClose

value
DeclarationView source
ToastClosets
export declare const ToastClose: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

ToastContextValue

interface
DeclarationView source
ToastContextValuets
export interface ToastContextValue {
    readonly service: ToastService;
    readonly connector: ToastApi;
    readonly scope: PartScope;
    readonly version: () => number;
}
Name
Kind
Type
Requirement
connector
property
ToastApi
required
scope
property
PartScope
required
service
property
ToastService
required
version
property
() => number
required
Name
connector
Kind
property
Type
ToastApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
ToastService
Requirement
required
Name
version
Kind
property
Type
() => number
Requirement
required

ToastDescription

value
DeclarationView source
ToastDescriptionts
export declare const ToastDescription: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

ToastIndicator

value
DeclarationView source
ToastIndicatorts
export declare const ToastIndicator: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

ToastItem

value
DeclarationView source
ToastItemts
export declare const ToastItem: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

ToastRoot

value
DeclarationView source
ToastRootts
export declare const ToastRoot: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

ToastTitle

value
DeclarationView source
ToastTitlets
export declare const ToastTitle: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

ToastToast

value
DeclarationView source
ToastToastts
export declare const ToastToast: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

ToastViewport

value
DeclarationView source
ToastViewportts
export declare const ToastViewport: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

useToastContext

function
DeclarationView source
useToastContextts
export declare function useToastContext(partName: string): ToastContextValue;
Name
Kind
Type
Requirement
partName
parameter
string
required
return
return value
ToastContextValue
n/a
Name
partName
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
ToastContextValue
Requirement
n/a

UseToastOptions

interface
DeclarationView source
UseToastOptionsts
export interface UseToastOptions {
    readonly scheduler?: Scheduler;
}
Name
Kind
Type
Requirement
scheduler
property
Scheduler
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional

UseToastResult

interface
DeclarationView source
UseToastResultts
export interface UseToastResult {
    readonly service: ToastService;
    readonly connector: ToastApi;
    readonly scope: PartScope;
    readonly version: () => number;
}
Name
Kind
Type
Requirement
connector
property
ToastApi
required
scope
property
PartScope
required
service
property
ToastService
required
version
property
() => number
required
Name
connector
Kind
property
Type
ToastApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
ToastService
Requirement
required
Name
version
Kind
property
Type
() => number
Requirement
required

wireEvents

function
DeclarationView source
wireEventsts
export declare function wireEvents(node: Element, params: {
    events: Record<string, EventListener>;
    ref?: (node: Element | null) => void;
}): {
    update(next: typeof params): void;
    destroy(): void;
};
Name
Kind
Type
Requirement
node
parameter
Element
required
params
parameter
{ events: Record<string, EventListener>; ref?: (node: Element | null) => void; }
required
return
return value
{ update(next: typeof params): void; destroy(): void; }
n/a
Name
node
Kind
parameter
Type
Element
Requirement
required
Name
params
Kind
parameter
Type
{ events: Record<string, EventListener>; ref?: (node: Element | null) => void; }
Requirement
required
Name
return
Kind
return value
Type
{ update(next: typeof params): void; destroy(): void; }
Requirement
n/a

@grassroot/ui-headless-solid/toast

Solid adapter

18 exports
View source packages/ui-headless/solid/src/toast/index.ts

ToastApi

interface
DeclarationView source
ToastApits
export interface ToastApi {
    readonly toasts: () => readonly ToastView[];
    toast(options: ToastAddOptions): string;
    dismiss(id: string): void;
}
Name
Kind
Type
Requirement
dismiss
method
(id: string) => void
required
toast
method
(options: ToastAddOptions) => string
required
toasts
property
() => readonly ToastView[]
required
Name
dismiss
Kind
method
Type
(id: string) => void
Requirement
required
Name
toast
Kind
method
Type
(options: ToastAddOptions) => string
Requirement
required
Name
toasts
Kind
property
Type
() => readonly ToastView[]
Requirement
required

ToastBody

value
DeclarationView source
ToastBodyts
export declare const ToastBody: (props: JSX.HTMLAttributes<HTMLElement> & {
    as?: AsProp;
    instanceKey: string;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ToastClose

value
DeclarationView source
ToastClosets
export declare const ToastClose: (props: JSX.HTMLAttributes<HTMLElement> & {
    as?: AsProp;
    instanceKey: string;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ToastContext

value
DeclarationView source
ToastContextts
export declare const ToastContext: import("solid-js").Context<ToastContextValue | undefined>;

ToastContextValue

interface
DeclarationView source
ToastContextValuets
export interface ToastContextValue {
    readonly service: ToastService;
    readonly connector: ToastApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<ToastSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
ToastApi
required
scope
property
PartScope
required
service
property
ToastService
required
snapshot
property
Accessor<ToastSnapshot>
required
Name
connector
Kind
property
Type
ToastApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
ToastService
Requirement
required
Name
snapshot
Kind
property
Type
Accessor<ToastSnapshot>
Requirement
required

ToastDescription

value
DeclarationView source
ToastDescriptionts
export declare const ToastDescription: (props: JSX.HTMLAttributes<HTMLElement> & {
    as?: AsProp;
    instanceKey: string;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ToastIndicator

value
DeclarationView source
ToastIndicatorts
export declare const ToastIndicator: (props: JSX.HTMLAttributes<HTMLElement> & {
    as?: AsProp;
    instanceKey: string;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ToastItem

value
DeclarationView source
ToastItemts
export declare const ToastItem: (props: JSX.HTMLAttributes<HTMLElement> & {
    as?: AsProp;
    instanceKey: string;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ToastRoot

function
DeclarationView source
ToastRootts
export declare function ToastRoot(props: ToastRootProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
ToastRootProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
ToastRootProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ToastRootProps

interface
DeclarationView source
ToastRootPropsts
export interface ToastRootProps {
    readonly scheduler?: Scheduler;
    readonly children?: JSX.Element;
}
Name
Kind
Type
Requirement
children
property
JSX.Element
optional
scheduler
property
Scheduler
optional
Name
children
Kind
property
Type
JSX.Element
Requirement
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional

ToastTitle

value
DeclarationView source
ToastTitlets
export declare const ToastTitle: (props: JSX.HTMLAttributes<HTMLElement> & {
    as?: AsProp;
    instanceKey: string;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ToastToast

value
DeclarationView source
ToastToastts
export declare const ToastToast: (props: JSX.HTMLAttributes<HTMLElement> & {
    as?: AsProp;
    instanceKey: string;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLElement> & { as?: AsProp; instanceKey: string; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ToastViewport

value
DeclarationView source
ToastViewportts
export declare const ToastViewport: (props: JSX.HTMLAttributes<HTMLDivElement> & {
    as?: AsProp;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLDivElement> & { as?: AsProp; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLDivElement> & { as?: AsProp; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

useToast

function
DeclarationView source
useToastts
export declare function useToast(): ToastApi;
Name
Kind
Type
Requirement
return
return value
ToastApi
n/a
Name
return
Kind
return value
Type
ToastApi
Requirement
n/a

useToastContext

function
DeclarationView source
useToastContextts
export declare function useToastContext(partName: string): ToastContextValue;
Name
Kind
Type
Requirement
partName
parameter
string
required
return
return value
ToastContextValue
n/a
Name
partName
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
ToastContextValue
Requirement
n/a

UseToastOptions

interface
DeclarationView source
UseToastOptionsts
export interface UseToastOptions {
    readonly scheduler?: Scheduler;
}
Name
Kind
Type
Requirement
scheduler
property
Scheduler
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional

useToastStore

function
DeclarationView source
useToastStorets
export declare function useToastStore(options?: UseToastOptions): UseToastStoreResult;
Name
Kind
Type
Requirement
options
parameter
UseToastOptions
optional
return
return value
UseToastStoreResult
n/a
Name
options
Kind
parameter
Type
UseToastOptions
Requirement
optional
Name
return
Kind
return value
Type
UseToastStoreResult
Requirement
n/a

UseToastStoreResult

interface
DeclarationView source
UseToastStoreResultts
export interface UseToastStoreResult {
    readonly service: ToastService;
    readonly connector: ToastApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<ToastSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
ToastApi
required
scope
property
PartScope
required
service
property
ToastService
required
snapshot
property
Accessor<ToastSnapshot>
required
Name
connector
Kind
property
Type
ToastApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
ToastService
Requirement
required
Name
snapshot
Kind
property
Type
Accessor<ToastSnapshot>
Requirement
required