@oxyhq/bloom 0.50.2 → 0.51.1

package/lib/module/toast/Toaster.js

@@ -0,0 +1,198 @@
+"use strict";
+
+/**
+ * Derived from sonner-native v0.26.4 — src/toaster.tsx
+ * (MIT © Gunnar Torfi Steinarsson). See the top-level NOTICE.
+ *
+ * Subscribes to the store, resolves the outlet configuration once, groups rows by
+ * position and renders each group through `Positioner` inside the platform
+ * `ToastHost`.
+ *
+ * W5 — ONE `AppState` subscription for the whole stack. Upstream subscribes per
+ * row, so N toasts meant N `visibilitychange` listeners all doing the same work;
+ * the store already exposes stack-wide `pauseAllTimers`/`resumeAllTimers`.
+ *
+ * `react-native-screens` is not imported here either — the platform wrapper is
+ * `ToastHost`'s concern (D6).
+ */
+import * as React from 'react';
+import { toastDefaults } from "./constants.js";
+import { DynamicToastContext, ToastContext } from "./context.js";
+import { getOrderedToastIds } from "./position-utils.js";
+import { Positioner } from "./Positioner.js";
+import { ToastHost } from './ToastHost';
+import { ToastRow } from "./ToastRow.js";
+import { toastStore } from "./toast-store.js";
+import { useAppStateChange } from "./use-app-state.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const ALL_POSITIONS = ['top-center', 'bottom-center', 'center'];
+
+// Stable identities so the context memos below do not invalidate every render.
+const EMPTY_TOAST_OPTIONS = {};
+const EMPTY_ICONS = {};
+const EMPTY_ANIMATION = {};
+
+/**
+ * A top-anchored stack grows downward from the newest toast, so its rows render
+ * in reverse order.
+ */
+function orderToastsFromPosition(toasts, position) {
+  return position === 'top-center' ? toasts.slice().reverse() : toasts;
+}
+export const Toaster = ({
+  ToasterOverlayWrapper,
+  ToastWrapper,
+  duration = toastDefaults.duration,
+  position = toastDefaults.position,
+  offset = toastDefaults.offset,
+  visibleToasts = toastDefaults.visibleToasts,
+  swipeToDismissDirection = toastDefaults.swipeToDismissDirection,
+  closeButton = toastDefaults.closeButton,
+  gap = toastDefaults.gap,
+  theme = toastDefaults.theme,
+  invert = toastDefaults.invert,
+  richColors = toastDefaults.richColors,
+  enableStacking = toastDefaults.enableStacking,
+  autoWiggleOnUpdate = toastDefaults.autoWiggleOnUpdate,
+  pauseWhenPageIsHidden = toastDefaults.pauseWhenPageIsHidden,
+  allowFontScaling = toastDefaults.allowFontScaling,
+  maxFontSizeMultiplier,
+  toastOptions = EMPTY_TOAST_OPTIONS,
+  icons = EMPTY_ICONS,
+  animation = EMPTY_ANIMATION,
+  unstyled,
+  positionerStyle,
+  style,
+  styles: styleOverrides
+}) => {
+  const {
+    toasts,
+    shouldShowOverlay,
+    toastHeights,
+    isExpanded
+  } = React.useSyncExternalStore(toastStore.subscribe, toastStore.getSnapshot, toastStore.getSnapshot);
+
+  // Runs even while idle: the store must know the outlet's limits BEFORE the
+  // first toast arrives, or that toast is resolved against the bare defaults.
+  React.useEffect(() => {
+    toastStore.setConfig({
+      autoWiggleOnUpdate,
+      visibleToasts,
+      duration,
+      pauseWhenPageIsHidden
+    });
+  }, [autoWiggleOnUpdate, visibleToasts, duration, pauseWhenPageIsHidden]);
+  const onBackground = React.useCallback(() => {
+    if (pauseWhenPageIsHidden) {
+      toastStore.pauseAllTimers();
+    }
+  }, [pauseWhenPageIsHidden]);
+  const onForeground = React.useCallback(() => {
+    if (pauseWhenPageIsHidden) {
+      toastStore.resumeAllTimers();
+    }
+  }, [pauseWhenPageIsHidden]);
+  useAppStateChange({
+    onBackground,
+    onForeground
+  });
+  const stableValue = React.useMemo(() => ({
+    duration,
+    position,
+    offset,
+    visibleToasts,
+    swipeToDismissDirection,
+    closeButton,
+    gap,
+    theme,
+    invert,
+    richColors,
+    enableStacking,
+    autoWiggleOnUpdate,
+    pauseWhenPageIsHidden,
+    allowFontScaling,
+    maxFontSizeMultiplier,
+    toastOptions,
+    icons,
+    animation,
+    unstyled: unstyled ?? toastOptions.unstyled ?? toastDefaults.unstyled
+  }), [duration, position, offset, visibleToasts, swipeToDismissDirection, closeButton, gap, theme, invert, richColors, enableStacking, autoWiggleOnUpdate, pauseWhenPageIsHidden, allowFontScaling, maxFontSizeMultiplier, toastOptions, icons, animation, unstyled]);
+  const dynamicValue = React.useMemo(() => ({
+    toastHeights,
+    isExpanded,
+    expand: toastStore.expand,
+    collapse: toastStore.collapse,
+    toggleExpand: toastStore.toggleExpand
+  }), [toastHeights, isExpanded]);
+
+  /**
+   * Rows grouped by their EFFECTIVE position, which for a toast with no explicit
+   * `position` is the outlet's configured one — the same resolution `ToastRow`
+   * itself does (`positionProp ?? positionCtx`).
+   *
+   * It must NOT be "whichever group happens to come first". Grouping a
+   * position-less row by index put it in the top-center group the moment any
+   * top-center toast existed, because `ALL_POSITIONS` starts with `top-center`:
+   * a plain `toast('Saved')` then rendered against the top inset (visible only as
+   * a sliver above the screen edge), and an already-placed one JUMPED there when a
+   * top-center toast arrived.
+   *
+   * The configured position is always kept, even with no rows in it, so
+   * position-less rows always have a home. Each group is ordered by its OWN
+   * position: a top-anchored stack renders in reverse, and applying the outlet's
+   * ordering to every group reversed the wrong ones.
+   */
+  const toastsByPosition = React.useMemo(() => {
+    const groups = new Map();
+    for (const candidate of ALL_POSITIONS) {
+      const group = toasts.filter(toast => (toast.position ?? position) === candidate);
+      if (candidate === position || group.length > 0) {
+        groups.set(candidate, orderToastsFromPosition(group, candidate));
+      }
+    }
+    return groups;
+  }, [toasts, position]);
+  const onDismiss = React.useCallback(id => {
+    toastStore.dismissToast(id, 'onDismiss');
+  }, []);
+
+  // Nothing to host while idle. `shouldShowOverlay` stays true for the length of
+  // the exit animation after the last dismissal, so this never cuts one short.
+  if (!shouldShowOverlay) {
+    return null;
+  }
+  return /*#__PURE__*/_jsx(ToastHost, {
+    ToasterOverlayWrapper: ToasterOverlayWrapper,
+    children: /*#__PURE__*/_jsx(ToastContext.Provider, {
+      value: stableValue,
+      children: /*#__PURE__*/_jsx(DynamicToastContext.Provider, {
+        value: dynamicValue,
+        children: Array.from(toastsByPosition, ([currentPosition, toastsForPosition]) => {
+          const orderedToastIds = getOrderedToastIds(toastsForPosition, currentPosition, enableStacking);
+          return /*#__PURE__*/_jsx(Positioner, {
+            position: currentPosition,
+            style: positionerStyle,
+            children: toastsForPosition.map((toast, index) => {
+              const row = /*#__PURE__*/_jsx(ToastRow, {
+                ...toast,
+                style: toast.style ?? style,
+                styles: toast.styles ?? styleOverrides,
+                index: index,
+                numberOfToasts: toastsForPosition.length,
+                orderedToastIds: orderedToastIds,
+                onDismiss: onDismiss,
+                ref: toastStore.getToastRef(toast.id)
+              }, toast.id);
+              return ToastWrapper ? /*#__PURE__*/_jsx(ToastWrapper, {
+                toastId: toast.id,
+                children: row
+              }, toast.id) : row;
+            })
+          }, currentPosition);
+        })
+      })
+    })
+  });
+};
+Toaster.displayName = 'Toaster';
+//# sourceMappingURL=Toaster.js.map

package/lib/module/toast/Toaster.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","toastDefaults","DynamicToastContext","ToastContext","getOrderedToastIds","Positioner","ToastHost","ToastRow","toastStore","useAppStateChange","jsx","_jsx","ALL_POSITIONS","EMPTY_TOAST_OPTIONS","EMPTY_ICONS","EMPTY_ANIMATION","orderToastsFromPosition","toasts","position","slice","reverse","Toaster","ToasterOverlayWrapper","ToastWrapper","duration","offset","visibleToasts","swipeToDismissDirection","closeButton","gap","theme","invert","richColors","enableStacking","autoWiggleOnUpdate","pauseWhenPageIsHidden","allowFontScaling","maxFontSizeMultiplier","toastOptions","icons","animation","unstyled","positionerStyle","style","styles","styleOverrides","shouldShowOverlay","toastHeights","isExpanded","useSyncExternalStore","subscribe","getSnapshot","useEffect","setConfig","onBackground","useCallback","pauseAllTimers","onForeground","resumeAllTimers","stableValue","useMemo","dynamicValue","expand","collapse","toggleExpand","toastsByPosition","groups","Map","candidate","group","filter","toast","length","set","onDismiss","id","dismissToast","children","Provider","value","Array","from","currentPosition","toastsForPosition","orderedToastIds","map","index","row","numberOfToasts","ref","getToastRef","toastId","displayName"],"sourceRoot":"../../../src","sources":["toast/Toaster.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/toast/animations.js

@@ -0,0 +1,261 @@
+"use strict";
+
+/**
+ * Derived from sonner-native v0.26.4 — src/animations.ts, src/animation-utils.ts
+ * and src/easings.ts (MIT © Gunnar Torfi Steinarsson). See the top-level NOTICE.
+ *
+ * W1 — THE EXIT DEFAULT IS A `Keyframe` INSTANCE, NOT A WORKLET BUILDER.
+ *
+ * Upstream returns a custom `EntryExitAnimationFunction` for both directions. On
+ * web that produces NO animation at all: reanimated's web layout-animation
+ * manager looks the builder up by preset name, finds none, logs a warning per
+ * toast and falls through to `makeElementVisible`, so a toast simply appears and
+ * disappears. A `ReanimatedKeyframe` compiles to a real CSS `@keyframes` rule on
+ * web and to the same interpolation on native, so one definition covers both
+ * platforms — which is what the exit default below is.
+ *
+ * ON WEB THE ENTER IS NOT A LAYOUT ANIMATION — NEVER HAND IT TO `entering`
+ * THERE. This is the fix for a blocker where a second toast landed exactly on top
+ * of the first, and it MUST NOT be undone by "simplifying" the web enter back
+ * into a `Keyframe`:
+ *
+ *   reanimated's web ENTERING path calls `setElementAnimation(element, config,
+ *   true)`, whose third argument is `shouldSavePosition`. For any animation name
+ *   that is not one of its own predefined presets — which is every `Keyframe`,
+ *   since those mint a fresh `REA-ENTERING-n` rule — it also schedules
+ *   `scheduleAnimationCleanup(name, duration, cb)`, and that callback runs
+ *   `setElementPosition(element, snapshot)`: `position: absolute`, an explicit
+ *   `top`/`left`/`width`/`height` and `transform: ''`, taken from a snapshot
+ *   captured when the enter animation ENDED. The timeout is `duration * 5`, so at
+ *   Bloom's 300ms enter the row is frozen in VIEWPORT coordinates 1500ms after it
+ *   appeared, and its parent collapses to `height: 0`. A row that moves inside
+ *   that window — i.e. any row that is still on screen when the next toast
+ *   arrives — has its stack translate exactly cancelled and redraws on top of the
+ *   newcomer. It is completely silent: no error, no warning.
+ *
+ * So on web the enter is driven imperatively instead: `ToastRow` seeds a shared
+ * value at 0 and animates it to 1 (`useAnimatedTarget`'s `from`), interpolating
+ * opacity and `ENTER_TRANSLATE_Y` to the same distances and curve the `Keyframe`
+ * uses, without touching reanimated's web layout-animation machinery.
+ *
+ * NATIVE KEEPS THE `Keyframe` ON `entering`. `ENTER_DRIVER` below is the ONE
+ * switch: there is no `setElementPosition` on native — that whole pin is a web-DOM
+ * behaviour — so native pays nothing for the web bug, and driving the enter
+ * imperatively there instead regressed it hard (a `bottom-center` toast stopped
+ * painting altogether). Native runs the device-verified layout-animation path and
+ * never starts a mount-time `withTiming` for the enter at all.
+ *
+ * The EXIT goes through `exiting` on BOTH platforms, which is safe: reanimated
+ * pins the throwaway dummy clone it animates (`shouldSavePosition` is false for
+ * the real element), and it is what keeps a dismissed row mounted long enough to
+ * animate.
+ *
+ * Consumer-supplied *predefined* builders (`FadeIn`, `SlideInUp`) keep working on
+ * both platforms for both enter and exit, and always go through `entering` /
+ * `exiting`. A consumer's own custom worklet builder still animates on native and
+ * is silently ignored on web, and a consumer's custom `Keyframe` passed as
+ * `animation.enter` will hit the pin described above on web — both are reanimated
+ * limitations Bloom cannot bridge.
+ *
+ * Exit instances are cached per animation shape because building one is not free
+ * and, more importantly, because `Keyframe.parseDefinitions()` MUTATES the
+ * definition object it was constructed with (it rewrites `from`/`to` into
+ * `0`/`100` and deletes them). Each cached instance therefore owns its own
+ * definition object; sharing one definition across two instances would make the
+ * second throw "Please provide 0 or 'from' keyframe". Re-parsing a single
+ * instance is idempotent, so one instance is safely shared by every row of the
+ * same shape.
+ */
+import { Platform } from 'react-native';
+import { Easing, Keyframe, useReducedMotion } from 'react-native-reanimated';
+import { ENTERING_ANIMATION_DURATION, toastDefaults } from "./constants.js";
+import { useToastContext } from "./context.js";
+/**
+ * `Easing.bezier()` (not `bezierFn`) returns an easing *factory*, which is what
+ * `Keyframe` accepts on both platforms — reanimated's dev-only worklet assertion
+ * short-circuits on the `.factory` property, so these pass without the worklets
+ * babel plugin too.
+ */
+const EASE_OUT_QUART = Easing.bezier(0.165, 0.84, 0.44, 1);
+const EASE_IN_OUT_CUBIC = Easing.bezier(0.645, 0.045, 0.355, 1);
+/**
+ * THE one platform switch in the toast engine: which mechanism plays Bloom's
+ * DEFAULT enter animation. See the header for why the two platforms cannot share
+ * one mechanism.
+ */
+export const TOAST_ENTER_DRIVER = Platform.OS === 'web' ? 'imperative' : 'layoutAnimation';
+
+/** Worklet-callable easing for `withTiming` inside mappers and layout transitions. */
+export const easeOutQuartFn = Easing.bezierFn(0.165, 0.84, 0.44, 1);
+export const easeInOutCircFn = Easing.bezierFn(0.785, 0.135, 0.15, 0.86);
+
+/** How far a row travels on the way in, per position. */
+const ENTER_TRANSLATE_Y = {
+  'top-center': -20,
+  'bottom-center': 50,
+  center: 50
+};
+
+/** A lone row leaves the screen entirely; a stacked one only slides by `stackGap`. */
+const EXIT_TRANSLATE_Y_SINGLE = 150;
+
+/**
+ * Bounded so an animated `gap` cannot grow the cache without limit. The natural
+ * key space is 3 enter shapes + 3 positions x hidden x single x one stackGap = 15
+ * entries, so this leaves room for a few gap values while staying O(1) memory.
+ */
+export const MAX_CACHED_ANIMATIONS = 32;
+const animationCache = new Map();
+function cachedAnimation(key, build) {
+  const hit = animationCache.get(key);
+  if (hit) {
+    return hit;
+  }
+  if (animationCache.size >= MAX_CACHED_ANIMATIONS) {
+    // Map iterates in insertion order, so this evicts the least recently added.
+    const oldest = animationCache.keys().next();
+    if (!oldest.done) {
+      animationCache.delete(oldest.value);
+    }
+  }
+  const built = build();
+  animationCache.set(key, built);
+  return built;
+}
+
+/** Exported so the bounded-growth invariant above is testable. */
+export function toastAnimationCacheSize() {
+  return animationCache.size;
+}
+
+/** Native only — on web the same shape is played imperatively by `ToastRow`. */
+export function getToastEnterAnimation(position) {
+  return cachedAnimation(`enter|${position}`, () => new Keyframe({
+    from: {
+      opacity: 0,
+      transform: [{
+        translateY: ENTER_TRANSLATE_Y[position]
+      }]
+    },
+    to: {
+      opacity: 1,
+      transform: [{
+        translateY: 0
+      }],
+      easing: EASE_OUT_QUART
+    }
+  }).duration(ENTERING_ANIMATION_DURATION));
+}
+export function getToastExitAnimation({
+  position,
+  isHiddenByLimit,
+  isSingle,
+  stackGap
+}) {
+  return cachedAnimation(`exit|${position}|${isHiddenByLimit}|${isSingle}|${stackGap}`, () => {
+    // A row culled by `visibleToasts` is buried under the stack; sliding it
+    // would look wrong, so it only fades.
+    if (isHiddenByLimit) {
+      return new Keyframe({
+        from: {
+          opacity: 1
+        },
+        to: {
+          opacity: 0,
+          easing: EASE_IN_OUT_CUBIC
+        }
+      }).duration(ENTERING_ANIMATION_DURATION);
+    }
+    const distance = isSingle ? EXIT_TRANSLATE_Y_SINGLE : stackGap;
+    const translateY = position === 'top-center' ? -distance : distance;
+    return new Keyframe({
+      from: {
+        opacity: 1,
+        transform: [{
+          translateY: 0
+        }]
+      },
+      to: {
+        opacity: 0,
+        transform: [{
+          translateY
+        }],
+        easing: EASE_IN_OUT_CUBIC
+      }
+    })
+    // Matches the store's overlay teardown delay, which is also
+    // ENTERING_ANIMATION_DURATION — a longer exit would be cut off.
+    .duration(ENTERING_ANIMATION_DURATION);
+  });
+}
+/**
+ * Pure so the platform split is testable without a renderer.
+ *
+ * INVARIANT: exactly ONE of `entering` / `enterTranslateY` is ever set. Both
+ * would play the enter twice; neither would leave the row with no enter animation
+ * at all and — on the imperative path — parked at `opacity: 0`, one full
+ * `enterTranslateY` away from its slot. A consumer override always wins and always
+ * goes through `entering`, on both platforms.
+ */
+export function resolveToastEnterAnimation({
+  position,
+  enterOverride,
+  driver
+}) {
+  if (enterOverride !== undefined && enterOverride !== 'default') {
+    return {
+      entering: enterOverride,
+      enterTranslateY: undefined
+    };
+  }
+  return driver === 'imperative' ? {
+    entering: undefined,
+    enterTranslateY: ENTER_TRANSLATE_Y[position]
+  } : {
+    entering: getToastEnterAnimation(position),
+    enterTranslateY: undefined
+  };
+}
+
+/** Per-toast animation wins over the outlet's; `'default'` opts back in to Bloom's. */
+export const resolveAnimationField = (toastValue, toasterValue, defaultValue) => {
+  const resolved = toastValue !== undefined ? toastValue : toasterValue;
+  if (resolved === undefined || resolved === 'default') {
+    return defaultValue;
+  }
+  return resolved;
+};
+export const useToastLayoutAnimations = (positionProp, animationProp, isHiddenByLimit, numberOfToasts) => {
+  const {
+    position: positionCtx,
+    gap,
+    animation: animationCtx
+  } = useToastContext();
+  const position = positionProp ?? positionCtx;
+  const stackGap = gap ?? toastDefaults.stackGap;
+  const reducedMotion = useReducedMotion();
+  if (reducedMotion) {
+    return {
+      entering: undefined,
+      exiting: undefined,
+      enterTranslateY: undefined
+    };
+  }
+  const defaultExiting = getToastExitAnimation({
+    position,
+    isHiddenByLimit,
+    isSingle: numberOfToasts <= 1,
+    stackGap
+  });
+  return {
+    ...resolveToastEnterAnimation({
+      position,
+      enterOverride: animationProp?.enter !== undefined ? animationProp.enter : animationCtx?.enter,
+      driver: TOAST_ENTER_DRIVER
+    }),
+    // An overflow-culled row always uses Bloom's fade: a consumer's custom exit
+    // would animate a row the user cannot even see.
+    exiting: isHiddenByLimit ? defaultExiting : resolveAnimationField(animationProp?.exit, animationCtx?.exit, defaultExiting)
+  };
+};
+//# sourceMappingURL=animations.js.map

package/lib/module/toast/animations.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Platform","Easing","Keyframe","useReducedMotion","ENTERING_ANIMATION_DURATION","toastDefaults","useToastContext","EASE_OUT_QUART","bezier","EASE_IN_OUT_CUBIC","TOAST_ENTER_DRIVER","OS","easeOutQuartFn","bezierFn","easeInOutCircFn","ENTER_TRANSLATE_Y","center","EXIT_TRANSLATE_Y_SINGLE","MAX_CACHED_ANIMATIONS","animationCache","Map","cachedAnimation","key","build","hit","get","size","oldest","keys","next","done","delete","value","built","set","toastAnimationCacheSize","getToastEnterAnimation","position","from","opacity","transform","translateY","to","easing","duration","getToastExitAnimation","isHiddenByLimit","isSingle","stackGap","distance","resolveToastEnterAnimation","enterOverride","driver","undefined","entering","enterTranslateY","resolveAnimationField","toastValue","toasterValue","defaultValue","resolved","useToastLayoutAnimations","positionProp","animationProp","numberOfToasts","positionCtx","gap","animation","animationCtx","reducedMotion","exiting","defaultExiting","enter","exit"],"sourceRoot":"../../../src","sources":["toast/animations.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/toast/constants.js

@@ -0,0 +1,52 @@
+"use strict";
+
+/**
+ * Derived from sonner-native v0.26.4 — src/constants.ts and src/animations.ts
+ * (MIT © Gunnar Torfi Steinarsson). See the top-level NOTICE.
+ *
+ * The two animation durations live HERE rather than in `animations.ts` so
+ * `toast-store.ts` never has to import a Reanimated-dependent module: the store
+ * stays pure JS and its suite needs zero React Native mocks.
+ */
+
+/** Fallback row height until a toast has been measured. */
+export const ESTIMATED_TOAST_HEIGHT = 70;
+export const CLOSE_BUTTON_HIT_AREA = 60;
+export const OUTSIDE_PRESS_PADDING = 20;
+/** However deep a stack gets, a buried row never narrows past this scale. */
+export const MIN_STACK_SCALE_X = 0.8;
+
+/** Enter animation length; also the auto-close timer's head start and the overlay teardown delay. */
+export const ENTERING_ANIMATION_DURATION = 300;
+export const STACKING_ANIMATION_DURATION = 600;
+export const toastDefaults = {
+  duration: 3000,
+  position: 'bottom-center',
+  /**
+   * 0 means "derive from the safe-area inset" — `getInsetValues` then yields
+   * `inset + 8`, or 16 when there is no inset. A non-zero default would pin the
+   * stack to a fixed offset and ignore the notch / home indicator entirely.
+   */
+  offset: 0,
+  swipeToDismissDirection: 'left',
+  /**
+   * No default variant: a plain `toast('Saved')` must render neutral. Upstream
+   * defaults this to `'info'`, which silently gives every unqualified toast
+   * info styling.
+   */
+  variant: undefined,
+  visibleToasts: 3,
+  closeButton: false,
+  dismissible: true,
+  unstyled: false,
+  invert: false,
+  pauseWhenPageIsHidden: true,
+  gap: 8,
+  theme: 'system',
+  autoWiggleOnUpdate: 'never',
+  richColors: false,
+  enableStacking: false,
+  stackGap: 8,
+  allowFontScaling: true
+};
+//# sourceMappingURL=constants.js.map

package/lib/module/toast/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ESTIMATED_TOAST_HEIGHT","CLOSE_BUTTON_HIT_AREA","OUTSIDE_PRESS_PADDING","MIN_STACK_SCALE_X","ENTERING_ANIMATION_DURATION","STACKING_ANIMATION_DURATION","toastDefaults","duration","position","offset","swipeToDismissDirection","variant","undefined","visibleToasts","closeButton","dismissible","unstyled","invert","pauseWhenPageIsHidden","gap","theme","autoWiggleOnUpdate","richColors","enableStacking","stackGap","allowFontScaling"],"sourceRoot":"../../../src","sources":["toast/constants.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AASA;AACA,OAAO,MAAMA,sBAAsB,GAAG,EAAE;AACxC,OAAO,MAAMC,qBAAqB,GAAG,EAAE;AACvC,OAAO,MAAMC,qBAAqB,GAAG,EAAE;AACvC;AACA,OAAO,MAAMC,iBAAiB,GAAG,GAAG;;AAEpC;AACA,OAAO,MAAMC,2BAA2B,GAAG,GAAG;AAC9C,OAAO,MAAMC,2BAA2B,GAAG,GAAG;AAE9C,OAAO,MAAMC,aAmBZ,GAAG;EACFC,QAAQ,EAAE,IAAI;EACdC,QAAQ,EAAE,eAAe;EACzB;AACF;AACA;AACA;AACA;EACEC,MAAM,EAAE,CAAC;EACTC,uBAAuB,EAAE,MAAM;EAC/B;AACF;AACA;AACA;AACA;EACEC,OAAO,EAAEC,SAAS;EAClBC,aAAa,EAAE,CAAC;EAChBC,WAAW,EAAE,KAAK;EAClBC,WAAW,EAAE,IAAI;EACjBC,QAAQ,EAAE,KAAK;EACfC,MAAM,EAAE,KAAK;EACbC,qBAAqB,EAAE,IAAI;EAC3BC,GAAG,EAAE,CAAC;EACNC,KAAK,EAAE,QAAQ;EACfC,kBAAkB,EAAE,OAAO;EAC3BC,UAAU,EAAE,KAAK;EACjBC,cAAc,EAAE,KAAK;EACrBC,QAAQ,EAAE,CAAC;EACXC,gBAAgB,EAAE;AACpB,CAAC","ignoreList":[]}

package/lib/module/toast/context.js

@@ -0,0 +1,34 @@
+"use strict";
+
+/**
+ * Derived from sonner-native v0.26.4 — src/context.tsx
+ * (MIT © Gunnar Torfi Steinarsson). See the top-level NOTICE.
+ *
+ * Two contexts, split by change frequency: the resolved `Toaster` configuration
+ * (stable for the lifetime of the outlet) and the live stack state (changes on
+ * every measurement). Splitting them keeps a height measurement from
+ * re-rendering every row's config-derived memo.
+ *
+ * Upstream also passes `addToast` through the stable context; Bloom's rows talk
+ * to `toastStore` directly, which is the single authority.
+ */
+import * as React from 'react';
+export const ToastContext = /*#__PURE__*/React.createContext(null);
+ToastContext.displayName = 'BloomToastContext';
+export const DynamicToastContext = /*#__PURE__*/React.createContext(null);
+DynamicToastContext.displayName = 'BloomDynamicToastContext';
+export const useToastContext = () => {
+  const context = React.useContext(ToastContext);
+  if (!context) {
+    throw new Error('useToastContext must be used within a <ToastOutlet>');
+  }
+  return context;
+};
+export const useDynamicToastContext = () => {
+  const context = React.useContext(DynamicToastContext);
+  if (!context) {
+    throw new Error('useDynamicToastContext must be used within a <ToastOutlet>');
+  }
+  return context;
+};
+//# sourceMappingURL=context.js.map

package/lib/module/toast/context.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","ToastContext","createContext","displayName","DynamicToastContext","useToastContext","context","useContext","Error","useDynamicToastContext"],"sourceRoot":"../../../src","sources":["toast/context.tsx"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAM9B,OAAO,MAAMC,YAAY,gBAAGD,KAAK,CAACE,aAAa,CAC7C,IACF,CAAC;AACDD,YAAY,CAACE,WAAW,GAAG,mBAAmB;AAE9C,OAAO,MAAMC,mBAAmB,gBAC9BJ,KAAK,CAACE,aAAa,CAAiC,IAAI,CAAC;AAC3DE,mBAAmB,CAACD,WAAW,GAAG,0BAA0B;AAE5D,OAAO,MAAME,eAAe,GAAGA,CAAA,KAA8B;EAC3D,MAAMC,OAAO,GAAGN,KAAK,CAACO,UAAU,CAACN,YAAY,CAAC;EAC9C,IAAI,CAACK,OAAO,EAAE;IACZ,MAAM,IAAIE,KAAK,CAAC,qDAAqD,CAAC;EACxE;EACA,OAAOF,OAAO;AAChB,CAAC;AAED,OAAO,MAAMG,sBAAsB,GAAGA,CAAA,KAA+B;EACnE,MAAMH,OAAO,GAAGN,KAAK,CAACO,UAAU,CAACH,mBAAmB,CAAC;EACrD,IAAI,CAACE,OAAO,EAAE;IACZ,MAAM,IAAIE,KAAK,CACb,4DACF,CAAC;EACH;EACA,OAAOF,OAAO;AAChB,CAAC","ignoreList":[]}