foldkit 0.69.0 → 0.71.0

package/dist/ui/toast/index.js

@@ -0,0 +1,158 @@
+import { Match as M } from 'effect';
+import { createLazy, html } from '../../html';
+import { Dismissed, DismissedAll, ElapsedDuration, GotTransitionMessage, HoveredEntry, LeftEntry, Position, Variant, } from './schema';
+import { DismissAfter, makeRuntime } from './update';
+export { Variant, Position, Dismissed, DismissedAll, ElapsedDuration, HoveredEntry, LeftEntry, GotTransitionMessage, DismissAfter, };
+const variantToRole = (variant) => M.value(variant).pipe(M.withReturnType(), M.when('Info', () => 'status'), M.when('Success', () => 'status'), M.when('Warning', () => 'alert'), M.when('Error', () => 'alert'), M.exhaustive);
+const positionToContainerStyle = (position) => {
+    const base = {
+        position: 'fixed',
+        display: 'flex',
+        gap: '8px',
+        padding: '16px',
+        margin: '0',
+        listStyle: 'none',
+        pointerEvents: 'none',
+        zIndex: '2147483600',
+    };
+    return M.value(position).pipe(M.withReturnType(), M.when('TopLeft', () => ({
+        ...base,
+        top: '0',
+        left: '0',
+        flexDirection: 'column-reverse',
+    })), M.when('TopCenter', () => ({
+        ...base,
+        top: '0',
+        left: '50%',
+        transform: 'translateX(-50%)',
+        flexDirection: 'column-reverse',
+    })), M.when('TopRight', () => ({
+        ...base,
+        top: '0',
+        right: '0',
+        flexDirection: 'column-reverse',
+    })), M.when('BottomLeft', () => ({
+        ...base,
+        bottom: '0',
+        left: '0',
+        flexDirection: 'column',
+    })), M.when('BottomCenter', () => ({
+        ...base,
+        bottom: '0',
+        left: '50%',
+        transform: 'translateX(-50%)',
+        flexDirection: 'column',
+    })), M.when('BottomRight', () => ({
+        ...base,
+        bottom: '0',
+        right: '0',
+        flexDirection: 'column',
+    })), M.exhaustive);
+};
+const DEFAULT_ARIA_LABEL = 'Notifications';
+/** Factory that binds `Ui.Toast` to a user-provided payload schema. The
+ *  returned module contains everything needed to wire a toast stack into an
+ *  app: `Model`, `Message`, `Entry`, `Added`, `init`, `update`, `show` /
+ *  `dismiss` / `dismissAll` helpers, and the headless `view`.
+ *
+ *  The payload is whatever content shape the consumer supplies via Schema.
+ *  The component never reads it — it flows through to `renderEntry`. The
+ *  component itself owns only lifecycle and a11y fields (id, variant,
+ *  transition, dismiss timer, hover state).
+ *
+ *  Consume the bound module's exports everywhere — `Toast.Model` in your app
+ *  Model, `Toast.Message` in your parent Message union, `Toast.show` /
+ *  `Toast.dismiss` in your update, `Toast.view` in your view. The top-level
+ *  exports (`Variant`, `Position`, static message tags, `DismissAfter`) are
+ *  payload-independent and safe to reference when you need them without a
+ *  bound module, but the typical path is through the factory return.
+ *
+ *  @example
+ *  ```ts
+ *  const ToastPayload = S.Struct({
+ *    bodyText: S.String,
+ *    maybeLink: S.OptionFromSelf(S.Struct({
+ *      href: S.String,
+ *      text: S.String,
+ *    })),
+ *  })
+ *  export const Toast = Ui.Toast.make(ToastPayload)
+ *  ```
+ */
+export const make = (payloadSchema) => {
+    const runtime = makeRuntime(payloadSchema);
+    /** Renders a headless toast stack. The `<ol>` container is always present
+     *  in the DOM so screen readers can observe its `aria-live` region from
+     *  page load. Each entry becomes an `<li>` keyed by its id, with
+     *  transition data attributes (`data-enter`, `data-leave`,
+     *  `data-transition`, `data-closed`) and `data-variant` reflecting the
+     *  entry's variant. */
+    const view = (config) => {
+        const { AriaAtomic, AriaLabel, AriaLive, Class, DataAttribute, Id, OnMouseEnter, OnMouseLeave, Role, Style, keyed, } = html();
+        const { model: { id, entries }, position, toParentMessage, renderEntry, ariaLabel = DEFAULT_ARIA_LABEL, className, attributes = [], entryClassName, entryAttributes = [], } = config;
+        const containerAttributes = [
+            Id(id),
+            Role('region'),
+            AriaLabel(ariaLabel),
+            AriaLive('polite'),
+            Style(positionToContainerStyle(position)),
+            ...(className ? [Class(className)] : []),
+            ...attributes,
+        ];
+        const renderEntryItem = (entry) => {
+            const { transitionState } = entry.transition;
+            const transitionAttributes = M.value(transitionState).pipe(M.when('EnterStart', () => [
+                DataAttribute('closed', ''),
+                DataAttribute('enter', ''),
+                DataAttribute('transition', ''),
+            ]), M.when('EnterAnimating', () => [
+                DataAttribute('enter', ''),
+                DataAttribute('transition', ''),
+            ]), M.when('LeaveStart', () => [
+                DataAttribute('leave', ''),
+                DataAttribute('transition', ''),
+            ]), M.when('LeaveAnimating', () => [
+                DataAttribute('closed', ''),
+                DataAttribute('leave', ''),
+                DataAttribute('transition', ''),
+            ]), M.orElse(() => []));
+            const handlers = {
+                dismiss: toParentMessage(Dismissed({ entryId: entry.id })),
+            };
+            const itemAttributes = [
+                Id(entry.id),
+                Role(variantToRole(entry.variant)),
+                AriaAtomic(true),
+                DataAttribute('variant', entry.variant),
+                Style({ pointerEvents: 'auto' }),
+                OnMouseEnter(toParentMessage(HoveredEntry({ entryId: entry.id }))),
+                OnMouseLeave(toParentMessage(LeftEntry({ entryId: entry.id }))),
+                ...transitionAttributes,
+                ...(entryClassName ? [Class(entryClassName)] : []),
+                ...entryAttributes,
+            ];
+            return keyed('li')(entry.id, itemAttributes, [
+                renderEntry(entry, handlers),
+            ]);
+        };
+        return keyed('ol')(id, containerAttributes, entries.map(renderEntryItem));
+    };
+    /** Creates a memoized toast container view. Static config (className,
+     *  entryClassName, etc.) is captured in a closure. Dynamic fields —
+     *  `model`, `toParentMessage`, and `renderEntry` — are compared by
+     *  reference per render via `createLazy`. */
+    const lazy = (staticConfig) => {
+        const lazyView = createLazy();
+        return (model, toParentMessage, renderEntry) => lazyView((currentModel, currentToMessage, currentRenderEntry) => view({
+            ...staticConfig,
+            model: currentModel,
+            toParentMessage: currentToMessage,
+            renderEntry: currentRenderEntry,
+        }), [model, toParentMessage, renderEntry]);
+    };
+    return {
+        ...runtime,
+        view,
+        lazy,
+    };
+};

package/dist/ui/toast/public.d.ts

@@ -0,0 +1,4 @@
+export { make, Variant, Position, Dismissed, DismissedAll, ElapsedDuration, HoveredEntry, LeftEntry, GotTransitionMessage, DismissAfter, } from './index';
+export type { EntryHandlers } from './index';
+export type { InitConfig, ShowInput } from './index';
+//# sourceMappingURL=public.d.ts.map

package/dist/ui/toast/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../src/ui/toast/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,SAAS,EACT,oBAAoB,EACpB,YAAY,GACb,MAAM,SAAS,CAAA;AAEhB,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC5C,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA"}

package/dist/ui/toast/public.js

@@ -0,0 +1 @@
+export { make, Variant, Position, Dismissed, DismissedAll, ElapsedDuration, HoveredEntry, LeftEntry, GotTransitionMessage, DismissAfter, } from './index';

package/dist/ui/toast/schema.d.ts

@@ -0,0 +1,143 @@
+import { Duration, Schema as S } from 'effect';
+/** Semantic category of a toast. Drives the default ARIA role: `status` for
+ *  `Info` / `Success`, `alert` for `Warning` / `Error`. Also surfaced as
+ *  `data-variant` on each entry for per-variant CSS. This is the only
+ *  content-adjacent field the component owns — the rest of the entry's
+ *  content lives in the user-provided payload. */
+export declare const Variant: S.Literal<["Info", "Success", "Warning", "Error"]>;
+export type Variant = typeof Variant.Type;
+/** Where the toast viewport is anchored on the screen and how entries stack. */
+export declare const Position: S.Literal<["TopLeft", "TopCenter", "TopRight", "BottomLeft", "BottomCenter", "BottomRight"]>;
+export type Position = typeof Position.Type;
+/** Schema factory for a single toast entry. `payloadSchema` is user-provided
+ *  and defines the shape of per-entry content — whatever the consumer wants
+ *  to encode. The component itself owns only lifecycle + a11y fields: `id`,
+ *  `variant` (for ARIA role), `transition`, `maybeDuration`,
+ *  `pendingDismissVersion` (for cancellable auto-dismiss), and `isHovered`
+ *  (for pause-on-hover). */
+export declare const makeEntry: <A, I>(payloadSchema: S.Schema<A, I>) => S.Struct<{
+    id: typeof S.String;
+    variant: S.Literal<["Info", "Success", "Warning", "Error"]>;
+    transition: S.Struct<{
+        id: typeof S.String;
+        isShowing: typeof S.Boolean;
+        transitionState: S.Literal<["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>;
+    }>;
+    maybeDuration: S.OptionFromSelf<typeof S.DurationFromMillis>;
+    pendingDismissVersion: typeof S.Number;
+    isHovered: typeof S.Boolean;
+    payload: S.Schema<A, I, never>;
+}>;
+/** Schema factory for the toast container's state. `nextEntryKey` is a
+ *  monotonic counter used to generate unique entry IDs purely from Model
+ *  state. Thread the updated model through successive `show()` calls —
+ *  calling `show()` twice against the same pre-update model in the same tick
+ *  will produce duplicate entry IDs. */
+export declare const makeModel: <A, I>(payloadSchema: S.Schema<A, I>) => S.Struct<{
+    id: typeof S.String;
+    defaultDuration: typeof S.DurationFromMillis;
+    entries: S.Array$<S.Struct<{
+        id: typeof S.String;
+        variant: S.Literal<["Info", "Success", "Warning", "Error"]>;
+        transition: S.Struct<{
+            id: typeof S.String;
+            isShowing: typeof S.Boolean;
+            transitionState: S.Literal<["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>;
+        }>;
+        maybeDuration: S.OptionFromSelf<typeof S.DurationFromMillis>;
+        pendingDismissVersion: typeof S.Number;
+        isHovered: typeof S.Boolean;
+        payload: S.Schema<A, I, never>;
+    }>>;
+    nextEntryKey: typeof S.Number;
+}>;
+/** Sent when an entry should begin dismissing. Starts the leave animation;
+ *  the entry is removed from the stack when `TransitionedOut` fires. */
+export declare const Dismissed: import("../../schema").CallableTaggedStruct<"Dismissed", {
+    entryId: typeof S.String;
+}>;
+/** Sent when every currently-visible entry should begin dismissing. */
+export declare const DismissedAll: import("../../schema").CallableTaggedStruct<"DismissedAll", {}>;
+/** Sent when an entry's auto-dismiss timer fires. Carries a version echoed
+ *  from the scheduling moment so stale timers (from hover or manual dismiss)
+ *  are discarded. */
+export declare const ElapsedDuration: import("../../schema").CallableTaggedStruct<"ElapsedDuration", {
+    entryId: typeof S.String;
+    version: typeof S.Number;
+}>;
+/** Sent when the pointer enters an entry. Pauses the auto-dismiss timer by
+ *  advancing the entry's version. */
+export declare const HoveredEntry: import("../../schema").CallableTaggedStruct<"HoveredEntry", {
+    entryId: typeof S.String;
+}>;
+/** Sent when the pointer leaves an entry. Restarts the auto-dismiss timer
+ *  with the entry's full duration. */
+export declare const LeftEntry: import("../../schema").CallableTaggedStruct<"LeftEntry", {
+    entryId: typeof S.String;
+}>;
+/** Wraps a single entry's Transition submodel message for delegation. */
+export declare const GotTransitionMessage: import("../../schema").CallableTaggedStruct<"GotTransitionMessage", {
+    entryId: typeof S.String;
+    message: S.Union<[import("../../schema").CallableTaggedStruct<"Showed", {}>, import("../../schema").CallableTaggedStruct<"Hid", {}>, import("../../schema").CallableTaggedStruct<"AdvancedTransitionFrame", {}>, import("../../schema").CallableTaggedStruct<"EndedTransition", {}>]>;
+}>;
+export type Dismissed = typeof Dismissed.Type;
+export type DismissedAll = typeof DismissedAll.Type;
+export type ElapsedDuration = typeof ElapsedDuration.Type;
+export type HoveredEntry = typeof HoveredEntry.Type;
+export type LeftEntry = typeof LeftEntry.Type;
+export type GotTransitionMessage = typeof GotTransitionMessage.Type;
+/** Factory for the `Added` message, which carries a fully-constructed entry
+ *  whose shape depends on the user-provided payload. */
+export declare const makeAdded: <A, I>(payloadSchema: S.Schema<A, I>) => import("../../schema").CallableTaggedStruct<"Added", {
+    entry: S.Struct<{
+        id: typeof S.String;
+        variant: S.Literal<["Info", "Success", "Warning", "Error"]>;
+        transition: S.Struct<{
+            id: typeof S.String;
+            isShowing: typeof S.Boolean;
+            transitionState: S.Literal<["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>;
+        }>;
+        maybeDuration: S.OptionFromSelf<typeof S.DurationFromMillis>;
+        pendingDismissVersion: typeof S.Number;
+        isHovered: typeof S.Boolean;
+        payload: S.Schema<A, I, never>;
+    }>;
+}>;
+/** Factory for the union of all messages the toast component can produce. */
+export declare const makeMessage: <A, I>(payloadSchema: S.Schema<A, I>) => S.Union<[import("../../schema").CallableTaggedStruct<"Added", {
+    entry: S.Struct<{
+        id: typeof S.String;
+        variant: S.Literal<["Info", "Success", "Warning", "Error"]>;
+        transition: S.Struct<{
+            id: typeof S.String;
+            isShowing: typeof S.Boolean;
+            transitionState: S.Literal<["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>;
+        }>;
+        maybeDuration: S.OptionFromSelf<typeof S.DurationFromMillis>;
+        pendingDismissVersion: typeof S.Number;
+        isHovered: typeof S.Boolean;
+        payload: S.Schema<A, I, never>;
+    }>;
+}>, import("../../schema").CallableTaggedStruct<"Dismissed", {
+    entryId: typeof S.String;
+}>, import("../../schema").CallableTaggedStruct<"DismissedAll", {}>, import("../../schema").CallableTaggedStruct<"ElapsedDuration", {
+    entryId: typeof S.String;
+    version: typeof S.Number;
+}>, import("../../schema").CallableTaggedStruct<"HoveredEntry", {
+    entryId: typeof S.String;
+}>, import("../../schema").CallableTaggedStruct<"LeftEntry", {
+    entryId: typeof S.String;
+}>, import("../../schema").CallableTaggedStruct<"GotTransitionMessage", {
+    entryId: typeof S.String;
+    message: S.Union<[import("../../schema").CallableTaggedStruct<"Showed", {}>, import("../../schema").CallableTaggedStruct<"Hid", {}>, import("../../schema").CallableTaggedStruct<"AdvancedTransitionFrame", {}>, import("../../schema").CallableTaggedStruct<"EndedTransition", {}>]>;
+}>]>;
+/** Configuration for creating a toast container model. `defaultDuration` is
+ *  applied to any `show()` call that doesn't provide its own `duration` or
+ *  pass `sticky: true`. Accepts any Effect Duration input; a bare number is
+ *  interpreted as milliseconds. */
+export type InitConfig = Readonly<{
+    id: string;
+    defaultDuration?: Duration.DurationInput;
+}>;
+export declare const DEFAULT_DURATION: Duration.Duration;
+//# sourceMappingURL=schema.d.ts.map

package/dist/ui/toast/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/ui/toast/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU9C;;;;kDAIkD;AAClD,eAAO,MAAM,OAAO,oDAAmD,CAAA;AACvE,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAIzC,gFAAgF;AAChF,eAAO,MAAM,QAAQ,8FAOpB,CAAA;AACD,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAI3C;;;;;4BAK4B;AAC5B,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;EASzD,CAAA;AAIJ;;;;wCAIwC;AACxC,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;EAMzD,CAAA;AAIJ;wEACwE;AACxE,eAAO,MAAM,SAAS;;EAAwC,CAAA;AAC9D,uEAAuE;AACvE,eAAO,MAAM,YAAY,iEAAoB,CAAA;AAC7C;;qBAEqB;AACrB,eAAO,MAAM,eAAe;;;EAG1B,CAAA;AACF;qCACqC;AACrC,eAAO,MAAM,YAAY;;EAA2C,CAAA;AACpE;sCACsC;AACtC,eAAO,MAAM,SAAS;;EAAwC,CAAA;AAC9D,yEAAyE;AACzE,eAAO,MAAM,oBAAoB;;;EAG/B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAC7C,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;AACzD,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AACnD,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAC7C,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE;wDACwD;AACxD,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;EACZ,CAAA;AAEjD,6EAA6E;AAC7E,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;IAS5D,CAAA;AAIH;;;mCAGmC;AACnC,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,eAAe,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAA;CACzC,CAAC,CAAA;AAEF,eAAO,MAAM,gBAAgB,mBAAsB,CAAA"}

package/dist/ui/toast/schema.js

@@ -0,0 +1,71 @@
+import { Duration, Schema as S } from 'effect';
+import { m } from '../../message';
+import { Message as TransitionMessage, Model as TransitionModel, } from '../transition/schema';
+// VARIANT
+/** Semantic category of a toast. Drives the default ARIA role: `status` for
+ *  `Info` / `Success`, `alert` for `Warning` / `Error`. Also surfaced as
+ *  `data-variant` on each entry for per-variant CSS. This is the only
+ *  content-adjacent field the component owns — the rest of the entry's
+ *  content lives in the user-provided payload. */
+export const Variant = S.Literal('Info', 'Success', 'Warning', 'Error');
+// POSITION
+/** Where the toast viewport is anchored on the screen and how entries stack. */
+export const Position = S.Literal('TopLeft', 'TopCenter', 'TopRight', 'BottomLeft', 'BottomCenter', 'BottomRight');
+// ENTRY
+/** Schema factory for a single toast entry. `payloadSchema` is user-provided
+ *  and defines the shape of per-entry content — whatever the consumer wants
+ *  to encode. The component itself owns only lifecycle + a11y fields: `id`,
+ *  `variant` (for ARIA role), `transition`, `maybeDuration`,
+ *  `pendingDismissVersion` (for cancellable auto-dismiss), and `isHovered`
+ *  (for pause-on-hover). */
+export const makeEntry = (payloadSchema) => S.Struct({
+    id: S.String,
+    variant: Variant,
+    transition: TransitionModel,
+    maybeDuration: S.OptionFromSelf(S.DurationFromMillis),
+    pendingDismissVersion: S.Number,
+    isHovered: S.Boolean,
+    payload: payloadSchema,
+});
+// MODEL
+/** Schema factory for the toast container's state. `nextEntryKey` is a
+ *  monotonic counter used to generate unique entry IDs purely from Model
+ *  state. Thread the updated model through successive `show()` calls —
+ *  calling `show()` twice against the same pre-update model in the same tick
+ *  will produce duplicate entry IDs. */
+export const makeModel = (payloadSchema) => S.Struct({
+    id: S.String,
+    defaultDuration: S.DurationFromMillis,
+    entries: S.Array(makeEntry(payloadSchema)),
+    nextEntryKey: S.Number,
+});
+// MESSAGE
+/** Sent when an entry should begin dismissing. Starts the leave animation;
+ *  the entry is removed from the stack when `TransitionedOut` fires. */
+export const Dismissed = m('Dismissed', { entryId: S.String });
+/** Sent when every currently-visible entry should begin dismissing. */
+export const DismissedAll = m('DismissedAll');
+/** Sent when an entry's auto-dismiss timer fires. Carries a version echoed
+ *  from the scheduling moment so stale timers (from hover or manual dismiss)
+ *  are discarded. */
+export const ElapsedDuration = m('ElapsedDuration', {
+    entryId: S.String,
+    version: S.Number,
+});
+/** Sent when the pointer enters an entry. Pauses the auto-dismiss timer by
+ *  advancing the entry's version. */
+export const HoveredEntry = m('HoveredEntry', { entryId: S.String });
+/** Sent when the pointer leaves an entry. Restarts the auto-dismiss timer
+ *  with the entry's full duration. */
+export const LeftEntry = m('LeftEntry', { entryId: S.String });
+/** Wraps a single entry's Transition submodel message for delegation. */
+export const GotTransitionMessage = m('GotTransitionMessage', {
+    entryId: S.String,
+    message: TransitionMessage,
+});
+/** Factory for the `Added` message, which carries a fully-constructed entry
+ *  whose shape depends on the user-provided payload. */
+export const makeAdded = (payloadSchema) => m('Added', { entry: makeEntry(payloadSchema) });
+/** Factory for the union of all messages the toast component can produce. */
+export const makeMessage = (payloadSchema) => S.Union(makeAdded(payloadSchema), Dismissed, DismissedAll, ElapsedDuration, HoveredEntry, LeftEntry, GotTransitionMessage);
+export const DEFAULT_DURATION = Duration.seconds(4);