@oxyhq/bloom 0.54.1 → 0.56.0

package/src/__tests__/toast-stack-hover.test.ts

@@ -0,0 +1,92 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { renderHook } from '@testing-library/react-native';
+
+import {
+  isStackHovered as isStackHoveredNative,
+  useStackHover as useStackHoverNative,
+} from '../toast/use-stack-hover.native';
+import { isStackHovered, useStackHover } from '../toast/use-stack-hover';
+
+/**
+ * The hover trigger's platform split. jest resolves the WEB file by default (as
+ * every non-Metro bundler and a consumer's `tsc` do), so `Toaster.test.tsx` covers
+ * the web behaviour through real rows; this file covers the NATIVE fork, which has
+ * no behaviour to exercise, plus the source properties that keep the split honest.
+ */
+const SRC = join(__dirname, '..');
+const read = (rel: string) => readFileSync(join(SRC, rel), 'utf8');
+const code = (rel: string) =>
+  read(rel)
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/^\s*\/\/.*$/gm, '');
+
+describe('stack hover platform split', () => {
+  it('native hands back no handlers at all, for either stacking value', () => {
+    const stacked = renderHook(() => useStackHoverNative({ enableStacking: true }));
+    const flat = renderHook(() => useStackHoverNative({ enableStacking: false }));
+
+    expect(Object.keys(stacked.result.current)).toEqual([]);
+    expect(Object.keys(flat.result.current)).toEqual([]);
+  });
+
+  it('native returns ONE object identity, so the row box props never churn', () => {
+    const { result, rerender } = renderHook(() =>
+      useStackHoverNative({ enableStacking: true }),
+    );
+    const first = result.current;
+    rerender(undefined);
+
+    expect(result.current).toBe(first);
+  });
+
+  it('nothing ever hovers on native', () => {
+    expect(isStackHoveredNative()).toBe(false);
+  });
+
+  it('web hands back both pointer handlers', () => {
+    const { result } = renderHook(() => useStackHover({ enableStacking: true }));
+
+    expect(typeof result.current.onPointerEnter).toBe('function');
+    expect(typeof result.current.onPointerLeave).toBe('function');
+  });
+
+  it('web is not hovered until a pointer says so', () => {
+    expect(isStackHovered()).toBe(false);
+  });
+
+  it('the native fork carries no hover state, no timer and no store import', () => {
+    const native = code('toast/use-stack-hover.native.ts');
+    // A native bundle must not ship the web file's module-level latch or its
+    // pending-leave timeout, which is the whole reason this is a file split rather
+    // than a `Platform.OS` branch.
+    expect(native).not.toMatch(/setTimeout/);
+    expect(native).not.toMatch(/from '\.\/toast-store'/);
+    expect(native).not.toMatch(/pointerType/);
+  });
+
+  it('the web fork gates on a mouse pointer', () => {
+    const web = code('toast/use-stack-hover.ts');
+    // Touch fires enter before pointerdown and leave after pointerup, so without
+    // this every tap on a touch-capable web device would expand then collapse.
+    expect(web).toMatch(/pointerType === 'mouse'/);
+  });
+
+  it('the web fork drives the store rather than a second expansion mechanism', () => {
+    const web = code('toast/use-stack-hover.ts');
+    expect(web).toMatch(/toastStore\.expand\(\)/);
+    expect(web).toMatch(/toastStore\.collapse\(\)/);
+    // With stacking off there is nothing to expand, so the pointer pauses directly.
+    expect(web).toMatch(/toastStore\.pauseAllTimers\(\)/);
+    expect(web).toMatch(/toastStore\.resumeAllTimers\(\)/);
+    // No parallel state: expansion lives in the store and nowhere else.
+    expect(web).not.toMatch(/useState/);
+    expect(web).not.toMatch(/isExpanded\s*=/);
+  });
+
+  it('the row box is the hover target and the press toggle stands down for it', () => {
+    expect(code('toast/ToastSwipeHandler.tsx')).toMatch(/\{\.\.\.hoverProps\}/);
+    // Hover owns expansion on web; a click must not toggle it shut again.
+    expect(code('toast/ToastRow.tsx')).toMatch(/else if \(!isStackHovered\(\)\)/);
+  });
+});

package/src/__tests__/toast-store.test.ts

@@ -17,6 +17,9 @@ describe('toastStore', () => {
   });
 
   afterEach(() => {
+    // The expansion hold is registered by whoever owns hovering, so a test that
+    // installs one must not leak it into the next.
+    toastStore.setExpansionHold(null);
     toastStore.dismissToast(undefined);
     // Drains the hide-overlay timeout so the next test starts from a clean state.
     jest.runOnlyPendingTimers();
@@ -573,6 +576,14 @@ describe('toastStore', () => {
       expect(toastStore.getSnapshot().isExpanded).toBe(true);
     });
 
+    /**
+     * The auto-collapse rule. A lone row renders identically expanded or collapsed
+     * (`toast-position-utils.test.ts`: "a single row is unmoved by expansion"), while
+     * `isExpanded` keeps every timer paused — so collapsing at one row is invisible
+     * and is the only thing that stops that last toast hanging on screen forever.
+     * The exception is a stack something is HOLDING open, which on web is a pointer
+     * resting on it.
+     */
     it('auto-collapses once only one toast is left', () => {
       const first = toastStore.addToast({ title: 'a' });
       toastStore.addToast({ title: 'b' });
@@ -581,6 +592,67 @@ describe('toastStore', () => {
       toastStore.dismissToast(first, 'onDismiss');
       expect(toastStore.getSnapshot().isExpanded).toBe(false);
     });
+
+    it('resumes the surviving toast on that auto-collapse, so it cannot hang', () => {
+      const first = toastStore.addToast({ title: 'a', duration: 1000 });
+      toastStore.addToast({ title: 'b', duration: 1000 });
+      toastStore.expand();
+
+      toastStore.dismissToast(first, 'onDismiss');
+      jest.advanceTimersByTime(ENTERING_ANIMATION_DURATION + 1000);
+
+      expect(toastStore.getSnapshot().toasts).toHaveLength(0);
+    });
+
+    it('stays expanded while more than one toast is left', () => {
+      const first = toastStore.addToast({ title: 'a' });
+      toastStore.addToast({ title: 'b' });
+      toastStore.addToast({ title: 'c' });
+      toastStore.expand();
+
+      toastStore.dismissToast(first, 'onDismiss');
+      expect(toastStore.getSnapshot().isExpanded).toBe(true);
+    });
+
+    it('does not auto-collapse a stack something is holding open', () => {
+      toastStore.setExpansionHold(() => true);
+      const first = toastStore.addToast({ title: 'a', duration: 1000 });
+      toastStore.addToast({ title: 'b', duration: 1000 });
+      toastStore.expand();
+
+      toastStore.dismissToast(first, 'onDismiss');
+
+      expect(toastStore.getSnapshot().isExpanded).toBe(true);
+      // Still paused: resuming here is what would let a hovered toast expire under
+      // the cursor.
+      jest.advanceTimersByTime(1_000_000);
+      expect(toastStore.getSnapshot().toasts).toHaveLength(1);
+    });
+
+    it('resets an EMPTY stack even while held', () => {
+      // Nothing can hold open a stack that no longer exists, and once the rows
+      // unmount no `pointerleave` ever arrives to release the hold — so this must
+      // not depend on it.
+      toastStore.setExpansionHold(() => true);
+      const only = toastStore.addToast({ title: 'a' });
+      toastStore.expand();
+
+      toastStore.dismissToast(only, 'onDismiss');
+
+      expect(toastStore.getSnapshot().toasts).toHaveLength(0);
+      expect(toastStore.getSnapshot().isExpanded).toBe(false);
+    });
+
+    it('stops consulting a hold once it is cleared', () => {
+      toastStore.setExpansionHold(() => true);
+      toastStore.setExpansionHold(null);
+      const first = toastStore.addToast({ title: 'a' });
+      toastStore.addToast({ title: 'b' });
+      toastStore.expand();
+
+      toastStore.dismissToast(first, 'onDismiss');
+      expect(toastStore.getSnapshot().isExpanded).toBe(false);
+    });
   });
 
   describe('subscription', () => {

package/src/provider/index.tsx

@@ -0,0 +1,68 @@
+/**
+ * `BloomProvider` — the ONE Bloom root an app mounts.
+ *
+ * Bloom's app-wide state used to be a handful of separate providers that every
+ * consumer wired by hand (theme, haptics, image resolution, scroll restoration,
+ * tab-bar minimize progress). Mounting them separately means each one can end
+ * up at a different depth, and a provider mounted too low fails in ways that
+ * are hard to trace:
+ *
+ *   - `useScrollRestoration()` THROWS on web outside `ScrollRestorationProvider`,
+ *     so any scrollable rendered beside the provider (a right rail, an overlay)
+ *     crashes the screen.
+ *   - `useMinimizeState()` silently hands each caller a private fallback, so a
+ *     tab bar below the provider just never minimizes — no error anywhere.
+ *
+ * Mounting this single provider at the app root makes both classes of mistake
+ * impossible: everything Bloom renders is under all of them, at the same depth.
+ * Nesting extra contexts costs nothing at runtime — the win is that scope is no
+ * longer a per-app decision.
+ *
+ * NOT included, on purpose — these are OUTLETS, not state, and their placement
+ * in the tree is a real app decision (z-order, safe areas, and mounting a
+ * second one duplicates every surface it renders):
+ * `<ToastOutlet>`, `<Portal.Provider>`/`<Portal.Outlet>`, `<SurfaceHost>`,
+ * `<BloomDialogProvider>`, `<AlertDialogHost>`.
+ */
+import type { ReactNode } from 'react';
+
+import { ImageResolverProvider, type ImageResolver } from '../image-resolver';
+import { BloomHapticsProvider } from '../hooks/useHaptics';
+import { TabBarMinimizeProvider } from '../tab-bar/minimize-context';
+import { BloomThemeProvider, type BloomThemeProviderProps } from '../theme';
+import { ScrollRestorationProvider } from './scroll-provider';
+
+export interface BloomProviderProps extends Omit<BloomThemeProviderProps, 'children'> {
+  children: ReactNode;
+  /**
+   * Resolves bare media identifiers (Oxy file ids) to loadable URLs for every
+   * Bloom surface that takes a `source` — `<Avatar>`, image galleries, cards.
+   * Typically `(id, variant) => oxyServices.getFileDownloadUrl(id, variant)`.
+   */
+  imageResolver?: ImageResolver;
+  /** `false` disables haptic feedback app-wide (honored by every `useHaptics()` call). */
+  haptics?: boolean;
+}
+
+export function BloomProvider({
+  children,
+  imageResolver,
+  haptics = true,
+  ...themeProps
+}: BloomProviderProps) {
+  return (
+    // `value` is passed unconditionally (null when unset) so toggling a resolver
+    // never changes the tree shape and remounts everything below it.
+    <ImageResolverProvider value={imageResolver ?? null}>
+      <BloomThemeProvider {...themeProps}>
+        <ScrollRestorationProvider>
+          <BloomHapticsProvider enabled={haptics}>
+            <TabBarMinimizeProvider>{children}</TabBarMinimizeProvider>
+          </BloomHapticsProvider>
+        </ScrollRestorationProvider>
+      </BloomThemeProvider>
+    </ImageResolverProvider>
+  );
+}
+
+BloomProvider.displayName = 'BloomProvider';

package/src/provider/scroll-provider.ts

@@ -0,0 +1,13 @@
+/**
+ * Native/default binding for the scroll-restoration provider used by
+ * {@link BloomProvider}.
+ *
+ * `@oxyhq/bloom/scroll` is web-forked, so its `browser` export condition hands
+ * web consumers the real implementation while native gets the no-op. A compiled
+ * `lib/module/provider/index.js` cannot benefit from that condition (it imports
+ * a relative path, not the package subpath), so the platform choice is made
+ * here by FILENAME instead: Metro picks `scroll-provider.web.ts` on web, and
+ * every web bundler that resolves `.web.js` picks the compiled sibling. Same
+ * mechanism the toast engine uses for `ToastHost.native.tsx`.
+ */
+export { ScrollRestorationProvider } from '../scroll';

package/src/provider/scroll-provider.web.ts

@@ -0,0 +1,2 @@
+/** Web binding for {@link BloomProvider}'s scroll-restoration provider — see `./scroll-provider.ts`. */
+export { ScrollRestorationProvider } from '../scroll/index.web';

package/src/toast/Toast.stories.tsx

@@ -26,6 +26,14 @@ import type { ToasterProps } from './types';
  * unstacked they must be ~54px apart (46px measured row + 8px gap), collapsed-
  * stack ~8px apart. Equal `y` values mean the rows are drawn on top of each
  * other — the failure this shape exists to catch.
+ *
+ * `Sequential*` gives you BOTH durations for a reason. The `One`/`Two` buttons use
+ * `duration: Infinity` so a row stays put while you inspect it — but that starts no
+ * auto-close timer at all, so nothing driven from those buttons can see the timer
+ * path. `One 3s`/`Two 3s` fire at the outlet's real duration; drive those when the
+ * question is a row's LIFETIME rather than its position. (`Toaster.test.tsx`'s
+ * "sequential toasts at the default duration" block covers the render set there;
+ * only a browser can judge the geometry.)
  */
 const meta: Meta = {
   title: 'Components/Toast',
@@ -249,6 +257,8 @@ function SequentialDemo({ outlet }: { outlet?: ToasterProps }) {
     <Demo outlet={outlet}>
       <Button onPress={() => toast('Row one', { duration: Infinity })}>One</Button>
       <Button onPress={() => toast('Row two', { duration: Infinity })}>Two</Button>
+      <Button onPress={() => toast('Row one')}>One 3s</Button>
+      <Button onPress={() => toast('Row two')}>Two 3s</Button>
     </Demo>
   );
 }

package/src/toast/ToastRow.tsx

@@ -60,6 +60,7 @@ import {
 } from './constants';
 import { useDynamicToastContext, useToastContext } from './context';
 import { calculateStackScaleX } from './position-utils';
+import { isStackHovered } from './use-stack-hover';
 import { useAnimatedTarget } from './use-animated-target';
 import { ToastContent } from './ToastContent';
 import { ToastSwipeHandler } from './ToastSwipeHandler';
@@ -354,18 +355,41 @@ export const ToastRow = React.forwardRef<ToastRef, ToastRowProps>(
       }
     }, [id, isExpanded]);
 
+    /**
+     * INVARIANT: NO TAP ON A STACKED ROW IS INERT. Every one of them dismisses,
+     * expands or collapses.
+     *
+     * The close-button strip dismisses only when a ✕ is actually THERE to aim at,
+     * which is exactly `closeButton && dismissible` — the same condition
+     * `ToastContent` renders it under, and nothing to do with expansion. Anything
+     * else in the strip falls through to the row's own behaviour rather than being
+     * swallowed: on a collapsed stack it expands, on an expanded one it collapses.
+     *
+     * Guarding the strip on `isExpanded` (as this did until now) made two taps do
+     * nothing at all — the whole strip at default config, where `closeButton` is
+     * `false` so the dismiss branch is unreachable, and the VISIBLE ✕ on a
+     * collapsed stack's front row. On Android that second one has no fallback:
+     * the RNGH tap wins the race against `ToastContent`'s nested close Pressable,
+     * so the ✕ never got its own press either.
+     *
+     * `x` is relative to the row, which is CAPPED at `TOAST_MAX_ROW_WIDTH`.
+     * Measuring the strip from the window edge would put it outside the row
+     * entirely on a wide viewport — do not "simplify" this back to `screenWidth`.
+     *
+     * W13 — the expansion TOGGLE stands down while a mouse is hovering the stack,
+     * because hover already owns expansion there (`use-stack-hover`). Without this
+     * a desktop click would collapse the stack under the cursor and resume the
+     * timers hover had just paused. Dismissing is unaffected, `onPress` always
+     * runs, and `isStackHovered()` is always false on native and on any touch web
+     * device — so press remains the only trigger wherever there is no pointer.
+     */
     const onSwipePress = React.useCallback(
       ({ x }: { x: number; y: number }) => {
         if (enableStacking && numberOfToasts > 1 && position !== 'center') {
-          // On Android the RNGH tap wins the race against the nested Pressable,
-          // so a press in the close-button strip has to dismiss explicitly.
-          // `x` is relative to the row, which is capped — measuring the strip
-          // from the window edge would put it outside the row on a wide viewport.
-          if (x > rowWidth - CLOSE_BUTTON_HIT_AREA) {
-            if (isExpanded && closeButton && dismissible) {
-              onDismiss(id);
-            }
-          } else {
+          const inCloseStrip = x > rowWidth - CLOSE_BUTTON_HIT_AREA;
+          if (inCloseStrip && closeButton && dismissible) {
+            onDismiss(id);
+          } else if (!isStackHovered()) {
             toggleExpand();
           }
         }
@@ -376,7 +400,6 @@ export const ToastRow = React.forwardRef<ToastRef, ToastRowProps>(
         numberOfToasts,
         position,
         rowWidth,
-        isExpanded,
         closeButton,
         dismissible,
         onDismiss,

package/src/toast/ToastSwipeHandler.tsx

@@ -14,6 +14,10 @@
  * covers `toast.custom` JSX and `unstyled` rows too, which never reach that
  * card. Every distance the gesture measures is a fraction of the capped
  * `rowWidth`, not of the window — see the constant.
+ *
+ * W13 — being THE row box also makes it the hover target: `useStackHover`'s
+ * handlers go here so a pointer over ANY row counts as a pointer over the stack.
+ * The handlers are empty on native.
  */
 import * as React from 'react';
 import {
@@ -37,6 +41,7 @@ import { easeInOutCircFn } from './animations';
 import { TOAST_MAX_ROW_WIDTH } from './constants';
 import { useToastContext } from './context';
 import type { ToastPosition, ToastProps } from './types';
+import { useStackHover } from './use-stack-hover';
 
 /** Fraction of the row a horizontal swipe must cross to dismiss. */
 const HORIZONTAL_DISMISS_FRACTION = 0.25;
@@ -76,10 +81,16 @@ export const ToastSwipeHandler: React.FC<
   // The row is `width: '100%'` up to the cap, so this is its real width.
   const rowWidth = Math.min(windowWidth, TOAST_MAX_ROW_WIDTH);
   const translate = useSharedValue(0);
-  const { swipeToDismissDirection: direction, position: positionCtx } =
-    useToastContext();
+  const {
+    swipeToDismissDirection: direction,
+    position: positionCtx,
+    enableStacking,
+  } = useToastContext();
   const position = positionProps ?? positionCtx;
   const isAndroid = Platform.OS === 'android';
+  // W13 — hover lives on THE ROW BOX, so hovering any row counts as hovering the
+  // stack. Empty on native; see `use-stack-hover.native.ts`.
+  const hoverProps = useStackHover({ enableStacking });
 
   const pan = Gesture.Pan()
     .onBegin(() => {
@@ -199,6 +210,7 @@ export const ToastSwipeHandler: React.FC<
           styles.rowBox,
           style,
         ]}
+        {...hoverProps}
         // W9 — on web `LinearTransition`'s easing degrades to CSS `ease` because
         // a `bezierFn` result carries no easing-name symbol for the CSS mapper.
         // Accepted: the transition still runs, only its curve differs.

package/src/toast/constants.ts

@@ -98,7 +98,24 @@ export const toastDefaults: {
   theme: 'system',
   autoWiggleOnUpdate: 'never',
   richColors: false,
-  enableStacking: false,
+  /**
+   * ON, unlike upstream — the same class of correction as `TOAST_MAX_ROW_WIDTH`.
+   *
+   * sonner-NATIVE defaults this off; sonner (web) has no switch at all, because a
+   * collapsed stack — front row full size, the ones behind scaled and offset,
+   * expanding on interaction — IS its default presentation. The port inherited the
+   * mobile default onto every desktop consumer, where an unstacked run of toasts
+   * is a column of full cards rather than a stack.
+   *
+   * Bloom already deviates deliberately elsewhere (`position: 'bottom-center'` vs
+   * upstream's `top-center`, `duration: 3000` vs 4000, `gap: 8` vs 14), so this is
+   * in keeping rather than a break with the port.
+   *
+   * Turning it OFF (`<ToastOutlet enableStacking={false} />`) restores the flat
+   * column, which is still the right choice for a surface that must show several
+   * toasts at once without an interaction.
+   */
+  enableStacking: true,
   stackGap: 8,
   allowFontScaling: true,
 };

package/src/toast/toast-store.ts

@@ -42,6 +42,7 @@ class ToastStore {
   private pendingPromises = new Set<string | number>();
   private collapseCooldown = false;
   private collapseCooldownTimeout: ReturnType<typeof setTimeout> | null = null;
+  private expansionHold: (() => boolean) | null = null;
 
   subscribe = (callback: Subscriber) => {
     this.subscribers.add(callback);
@@ -59,6 +60,24 @@ class ToastStore {
     this.config = config;
   };
 
+  /**
+   * Something outside the store can HOLD an expanded stack open — on web, a pointer
+   * resting on it. Registered by the platform trigger (`use-stack-hover`) so this
+   * module stays pure JS with no DOM and no platform branch; native registers
+   * nothing and the predicate stays `null`.
+   *
+   * It is asked at DECISION time rather than tracked as state on purpose: a row can
+   * stop being under the pointer with no event at all — rows unmount under the
+   * cursor and move under a stationary one, and neither fires `pointerleave` —
+   * so any cached boolean goes stale. Nothing renders from this, so it is
+   * deliberately not part of the snapshot.
+   */
+  setExpansionHold = (hold: (() => boolean) | null) => {
+    this.expansionHold = hold;
+  };
+
+  private isHeldOpen = (): boolean => this.expansionHold?.() === true;
+
   private notify = () => {
     this.subscribers.forEach((callback) => callback());
   };
@@ -305,8 +324,27 @@ class ToastStore {
     const updatedRefs = { ...this.state.toastRefs };
     delete updatedRefs[id];
 
+    /**
+     * An expanded stack collapses itself once a single row is left, because
+     * "expanded" then means nothing visually — a lone row resolves to the SAME
+     * offset and scale either way (`toast-position-utils.test.ts` pins that) — while
+     * `isExpanded` keeps every timer paused, so staying expanded would leave that
+     * last toast on screen forever with no visible reason. Inherited from
+     * sonner-native and kept deliberately: on native it is invisible and it is the
+     * only thing that stops the last row hanging.
+     *
+     * UNLESS something is holding the stack open. On web that is a pointer resting
+     * on it, and collapsing under the cursor would resume the timers hover had just
+     * paused — the toast would then expire while the user is reading it, which is
+     * exactly what hover exists to prevent.
+     *
+     * An EMPTY stack always resets, hold or no hold: it no longer exists to be held,
+     * and once the rows unmount no `pointerleave` will ever arrive to release it.
+     */
+    const isEmpty = filteredToasts.length === 0;
+    const heldOpen = !isEmpty && this.isHeldOpen();
     const shouldAutoCollapse =
-      filteredToasts.length <= 1 && this.state.isExpanded;
+      filteredToasts.length <= 1 && this.state.isExpanded && !heldOpen;
 
     const updatedIndex = this.cloneIndex();
     updatedIndex.delete(id);

package/src/toast/use-stack-hover.native.ts

@@ -0,0 +1,34 @@
+/**
+ * Bloom-original — NATIVE. Metro resolves this over `use-stack-hover.ts` on iOS and
+ * Android, the same filename split `ToastHost.native.tsx` uses.
+ *
+ * Native keeps PRESS as the only way to expand a stack, so this hands back no
+ * handlers at all. Two reasons it is a fork rather than a runtime `Platform` check:
+ * the web file's module-level hover state and its `setTimeout` have no business
+ * existing in a native bundle, and `onPointerEnter`/`onPointerLeave` DO fire on
+ * native for touch (RN's pointer events unify touch and mouse), which would make
+ * every tap expand-then-collapse while the press toggle fired as well.
+ *
+ * Keep the shape identical to the web file — `ToastSwipeHandler` spreads whatever
+ * this returns onto the row box, and `ToastRow` calls `isStackHovered()`
+ * unconditionally.
+ */
+export type StackHoverProps = Record<string, never>;
+
+/** Parity with the web file's export; nothing here waits for anything. */
+export const HOVER_LEAVE_GRACE = 0;
+
+/** Nothing hovers on a touch screen. */
+export function isStackHovered(): boolean {
+  return false;
+}
+
+/** One frozen object, so spreading it never changes the row box's props. */
+const NO_HOVER_PROPS: StackHoverProps = Object.freeze({});
+
+export function useStackHover(_options: { enableStacking: boolean }): StackHoverProps {
+  return NO_HOVER_PROPS;
+}
+
+/** Parity with the web file so the shared suite can call it on either platform. */
+export function resetStackHoverForTests(): void {}