@applicaster/quick-brick-core 16.0.0-alpha.9534912292 → 16.0.0-alpha.9739533780

package/App/ActionsProvider/ActionsProvider.tsx

@@ -3,6 +3,14 @@ import * as R from "ramda";
 
 import { ActionsContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ActionsContext";
 import { isNilOrEmpty } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+
+import { LegacyActionsRegistryAdapter } from "./LegacyActionsRegistryAdapter";
+
+const { log_debug } = createLogger({
+  subsystem: "ActionsProvider",
+  category: "ActionRegistration",
+});
 
 type Props = {
   children: React.ReactNode;
@@ -36,19 +44,17 @@ const abstractIdentifier = (actionPlugins: Plugin[]): PluginsIdMap =>
  * Component returning children.
  * Can be used to create Component from children
  */
-const ChildrenWrapper = ({
-  children,
-}: {
-  children: React.ReactElement<any>;
-}) => {
-  return children;
+const ChildrenWrapper = ({ children }: { children: React.ReactNode }) => {
+  return <>{children}</>;
 };
 
 /**
  * It wraps children in multiple context providers
  * @param contexts - Array of React Context Providers
  */
-const contextComposer = (contexts: Plugin[]): React.ExoticComponent =>
+const contextComposer = (
+  contexts: Plugin[]
+): React.ComponentType<React.PropsWithChildren> =>
   R.compose(...contexts)(ChildrenWrapper);
 
 /**
@@ -69,6 +75,19 @@ export function ActionsProvider(props: Props) {
     [plugins]
   );
 
+  React.useEffect(() => {
+    const count = Object.keys(actionPlugins).length;
+
+    if (count > 0) {
+      log_debug(
+        `ActionsProvider: composed ${count} action plugin(s) into context`,
+        { identifiers: Object.keys(actionPlugins) }
+      );
+    } else {
+      log_debug("ActionsProvider: no action plugins to compose");
+    }
+  }, [actionPlugins]);
+
   const contextProviders = React.useMemo((): [Plugin] | [] => {
     try {
       const providers = R.compose(
@@ -88,7 +107,7 @@ export function ActionsProvider(props: Props) {
         ? contextComposer(contextProviders)
         : React.Fragment,
     []
-  );
+  ) as React.ComponentType<React.PropsWithChildren>;
 
   const contextValue = React.useMemo(
     () => ({ actions: actionPlugins }),
@@ -97,7 +116,10 @@ export function ActionsProvider(props: Props) {
 
   return (
     <ActionsContext.Provider value={contextValue}>
-      <Context>{children}</Context>
+      <Context>
+        <LegacyActionsRegistryAdapter actionPlugins={actionPlugins} />
+        {children}
+      </Context>
     </ActionsContext.Provider>
   );
 }

package/App/ActionsProvider/LegacyActionsRegistryAdapter.tsx

@@ -0,0 +1,107 @@
+import * as React from "react";
+import * as R from "ramda";
+
+import { uiActionsRegistry } from "@applicaster/zapp-react-native-utils/uiActionsRegistrator";
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+
+const { log_debug, log_warning } = createLogger({
+  subsystem: "LegacyActionsRegistryAdapter",
+  category: "ActionRegistration",
+});
+
+type LegacyActionPlugin = Record<string, any> & {
+  identifier: string;
+  module: {
+    context?: React.Context<any>;
+    [key: string]: any;
+  };
+};
+
+/**
+ * Bridges a single legacy action plugin (one that exposes `module.context`)
+ * into the `uiActionsRegistry`.
+ *
+ * Reactivity note: legacy stateful actions rely on React Context re-renders to
+ * propagate their latest value to subscribed UI (via `useActions`). We keep
+ * that mechanism intact and only *mirror* the current value into the registry
+ * through a ref, so registry-based consumers always read the freshest value at
+ * call time without changing legacy reactivity.
+ */
+function LegacyActionBridge({ plugin }: { plugin: LegacyActionPlugin }) {
+  // `plugin.module.context` is stable for the lifetime of the plugin, so this
+  // single `useContext` call is safe and rules-of-hooks compliant.
+  const value = React.useContext(plugin.module.context as React.Context<any>);
+
+  const valueRef = React.useRef(value);
+  valueRef.current = value;
+
+  React.useEffect(() => {
+    if (value == null) {
+      log_warning(
+        `LegacyActionBridge: context value for "${plugin.identifier}" is null/undefined – skipping registration`,
+        { identifier: plugin.identifier }
+      );
+    } else {
+      log_debug(
+        `LegacyActionBridge: context value ready for "${plugin.identifier}", registering in UIActionsRegistry`,
+        { identifier: plugin.identifier }
+      );
+    }
+
+    const unregister = uiActionsRegistry.registerActionProvider(
+      plugin.identifier,
+      () =>
+        valueRef.current
+          ? [{ identifier: plugin.identifier, action: valueRef.current }]
+          : []
+    );
+
+    return () => {
+      log_debug(
+        `LegacyActionBridge: unmounting bridge for "${plugin.identifier}"`,
+        { identifier: plugin.identifier }
+      );
+
+      unregister();
+    };
+  }, [plugin.identifier]);
+
+  return null;
+}
+
+type Props = {
+  actionPlugins: Record<string, LegacyActionPlugin>;
+};
+
+/**
+ * Registers every legacy action plugin's live context value into the
+ * `uiActionsRegistry`. It must be rendered *inside* the composed context
+ * providers (see `ActionsProvider`) so that each plugin's context is populated.
+ *
+ * This is the compatibility layer that lets new, registry-based consumers read
+ * actions coming from old plugins that still export `contextProvider`/`context`.
+ */
+export function LegacyActionsRegistryAdapter({ actionPlugins }: Props) {
+  const bridgedPlugins = React.useMemo(
+    () =>
+      R.values(actionPlugins).filter(
+        (plugin) => plugin?.module?.context != null
+      ),
+    [actionPlugins]
+  );
+
+  log_debug(
+    `LegacyActionsRegistryAdapter: bridging ${bridgedPlugins.length} legacy action plugin(s)`,
+    { identifiers: bridgedPlugins.map((p) => p.identifier) }
+  );
+
+  return (
+    <>
+      {bridgedPlugins.map((plugin) => (
+        <LegacyActionBridge key={plugin.identifier} plugin={plugin} />
+      ))}
+    </>
+  );
+}
+
+LegacyActionsRegistryAdapter.displayName = "LegacyActionsRegistryAdapter";

package/App/NotificationToastRenderer/NotificationToastManager.ts

@@ -0,0 +1,203 @@
+import { subscriber } from "@applicaster/zapp-react-native-utils/functionUtils";
+import { subscriberFor } from "@applicaster/zapp-react-native-utils/reactHooks/useSubscriberFor";
+
+// events accepted on the shared cross-package event bus (see useSubscriberFor),
+// so packages that must not depend on quick-brick-core (e.g. OfflineHandler in
+// zapp-react-native-ui-components) can trigger a toast by event name alone,
+// without importing notificationToastManager directly.
+const unwrapEventPayload = (payload: unknown) =>
+  Array.isArray(payload) ? payload[0] : payload;
+
+export const NOTIFICATION_TOAST_EVENTS = {
+  SHOW_TOAST: "showToast", // in: request to enqueue a toast
+  DISMISS: "dismiss", // in: renderer/user dismissed the visible toast early
+  SHOW: "show", // out: renderer should display this toast
+  HIDE: "hide", // out: renderer should hide the current toast
+} as const;
+
+export interface ToastStyle {
+  backgroundColor?: string;
+  color?: string;
+  fontFamily?: string;
+  fontSize?: number;
+  lineHeight?: number;
+  letterSpacing?: number;
+}
+
+export interface ToastPayload {
+  id?: string;
+  message: string;
+  extraMessage?: string; // secondary line; TV renderers show it as a subtitle, mobile ignores it
+  timeout?: number; // ms; if omitted, toast stays until dismissed
+  style?: ToastStyle;
+  [key: string]: unknown;
+}
+
+class NotificationToastManager {
+  private static instance: NotificationToastManager;
+
+  private eventHandler = subscriber();
+  private queue: ToastPayload[] = [];
+  private hideTimer: ReturnType<typeof setTimeout> | null = null;
+  private isShowing = false;
+  private nextId = 0;
+
+  private constructor() {
+    // subscribe to the shared event bus so other packages can trigger toasts
+    subscriberFor(
+      NOTIFICATION_TOAST_EVENTS.SHOW_TOAST,
+      this.handleShowToastEvent
+    );
+
+    subscriberFor(NOTIFICATION_TOAST_EVENTS.DISMISS, this.handleDismiss);
+
+    this.getCurrentState = this.getCurrentState.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+  }
+
+  static getInstance(): NotificationToastManager {
+    if (!NotificationToastManager.instance) {
+      NotificationToastManager.instance = new NotificationToastManager();
+    }
+
+    return NotificationToastManager.instance;
+  }
+
+  on(event: string, callback: (...args: any[]) => void) {
+    this.eventHandler.on(event, callback);
+  }
+
+  removeHandler(event: string, callback: (...args: any[]) => void) {
+    this.eventHandler.removeHandler(event, callback);
+  }
+
+  showToast(payload: ToastPayload) {
+    this.handleShowToast(payload);
+  }
+
+  dismiss() {
+    this.handleDismiss();
+  }
+
+  getCurrentState() {
+    return this.queue[0] ?? null;
+  }
+
+  subscribe(callback) {
+    this.eventHandler.on(NOTIFICATION_TOAST_EVENTS.SHOW, callback);
+
+    this.eventHandler.on(NOTIFICATION_TOAST_EVENTS.HIDE, callback);
+
+    return () => {
+      this.eventHandler.removeHandler(NOTIFICATION_TOAST_EVENTS.SHOW, callback);
+
+      this.eventHandler.removeHandler(NOTIFICATION_TOAST_EVENTS.HIDE, callback);
+    };
+  }
+
+  // subscriberFor's shared bus can deliver the raw payload (component emitters,
+  // see useSubscriberFor) or an args array (postEvent-style callers) - accept both.
+  private handleShowToastEvent = (payload: unknown) => {
+    if (!payload) {
+      console.warn(
+        "NotificationToastManager: Invalid showToast payload:",
+        payload
+      );
+
+      return;
+    }
+
+    const unwrappedPayload = unwrapEventPayload(payload) as ToastPayload;
+
+    if (!unwrappedPayload || typeof unwrappedPayload.message !== "string") {
+      console.warn(
+        "NotificationToastManager: Invalid showToast payload:",
+        payload
+      );
+
+      return;
+    }
+
+    this.handleShowToast(unwrappedPayload);
+  };
+
+  private handleShowToast = (payload: ToastPayload) => {
+    const item = { ...payload, id: payload.id ?? String(this.nextId++) };
+
+    const queuedIndex = this.queue.findIndex((queued) => queued.id === item.id);
+
+    if (queuedIndex === -1) {
+      this.queue.push(item);
+    } else if (queuedIndex === 0 && this.isShowing) {
+      // this id is the toast currently on screen - swap its content in place
+      // (new one appears in front of it) and dismiss the old timer/content
+      this.clearTimer();
+      this.queue[0] = item;
+      this.eventHandler.invokeHandler(NOTIFICATION_TOAST_EVENTS.SHOW, item);
+
+      if (item.timeout) {
+        this.hideTimer = setTimeout(() => this.finishCurrent(), item.timeout);
+      }
+
+      return;
+    } else {
+      // still queued, not yet shown - update it in place instead of duplicating
+      this.queue[queuedIndex] = item;
+
+      return;
+    }
+
+    if (!this.isShowing) {
+      this.processNext();
+    }
+  };
+
+  private handleDismiss = () => {
+    if (!this.isShowing) {
+      return;
+    }
+
+    this.finishCurrent();
+  };
+
+  private processNext() {
+    const next = this.queue[0];
+
+    if (!next) {
+      this.isShowing = false;
+
+      return;
+    }
+
+    this.isShowing = true;
+    this.eventHandler.invokeHandler(NOTIFICATION_TOAST_EVENTS.SHOW, next);
+
+    if (next.timeout) {
+      this.hideTimer = setTimeout(() => this.finishCurrent(), next.timeout);
+    }
+  }
+
+  private finishCurrent() {
+    this.clearTimer();
+    this.queue.shift();
+    this.eventHandler.invokeHandler(NOTIFICATION_TOAST_EVENTS.HIDE);
+    this.isShowing = false;
+    this.processNext();
+  }
+
+  private clearTimer() {
+    if (this.hideTimer) {
+      clearTimeout(this.hideTimer);
+      this.hideTimer = null;
+    }
+  }
+
+  public reset(): void {
+    this.clearTimer();
+    this.queue = [];
+    this.isShowing = false;
+    this.nextId = 0;
+  }
+}
+
+export const notificationToastManager = NotificationToastManager.getInstance();

package/App/NotificationToastRenderer/NotificationToastRenderer.tsx

@@ -0,0 +1,102 @@
+import React, { useEffect, useRef, useState } from "react";
+import {
+  View,
+  Text,
+  Animated,
+  StyleSheet,
+  TouchableWithoutFeedback,
+  ViewStyle,
+} from "react-native";
+
+import { notificationToastManager } from "./NotificationToastManager";
+import { useNotificationToastState } from "./useNotificationToastState";
+import { useNotificationHeight } from "./useNotificationHeight";
+
+const styles = StyleSheet.create({
+  notificationView: {
+    flex: 1,
+    position: "absolute",
+    alignItems: "center",
+    justifyContent: "center",
+    top: 0,
+    left: 0,
+    right: 0,
+  },
+});
+
+type NumberBoolean = 0 | 1;
+
+export const NotificationToastRenderer = ({ children }) => {
+  const { statusHeight, notificationHeight } = useNotificationHeight();
+
+  const toast = useNotificationToastState();
+
+  const [notificationOpacity, setNotificationOpacity] =
+    useState<NumberBoolean>(0);
+
+  const yPosition = useRef(new Animated.Value(0)).current;
+
+  const backgroundColor = toast?.style?.backgroundColor ?? "#000";
+  const color = toast?.style?.color ?? "#fff";
+
+  const textStyles = {
+    color,
+    fontFamily: toast?.style?.fontFamily,
+    fontSize: toast?.style?.fontSize,
+    lineHeight: toast?.style?.lineHeight,
+    letterSpacing: toast?.style?.letterSpacing,
+  };
+
+  const animatedViewStyles: ViewStyle = {
+    ...styles.notificationView,
+    transform: [
+      {
+        translateY: yPosition.interpolate({
+          inputRange: [0, 1],
+          outputRange: [-notificationHeight, 0],
+        }),
+      },
+    ],
+    opacity: notificationOpacity,
+    height: notificationHeight,
+    width: "100%",
+
+    backgroundColor,
+  };
+
+  useEffect(() => {
+    if (toast) {
+      setNotificationOpacity(1);
+
+      Animated.timing(yPosition, {
+        toValue: 1,
+        useNativeDriver: true,
+        duration: 300,
+      }).start();
+    } else {
+      Animated.timing(yPosition, {
+        toValue: 0,
+        useNativeDriver: true,
+        duration: 300,
+      }).start(() => setNotificationOpacity(0));
+    }
+  }, [toast]);
+
+  return (
+    <View testID="NotificationToastRenderer" style={StyleSheet.absoluteFill}>
+      {children}
+      <TouchableWithoutFeedback
+        testID="NotificationToastRenderer-touchable"
+        style={styles.notificationView}
+        onPress={() => notificationToastManager.dismiss()}
+      >
+        <Animated.View style={animatedViewStyles}>
+          <View style={{ height: statusHeight, backgroundColor }} />
+          <Text testID="NotificationToastRenderer-message" style={textStyles}>
+            {toast?.message}
+          </Text>
+        </Animated.View>
+      </TouchableWithoutFeedback>
+    </View>
+  );
+};

package/App/NotificationToastRenderer/NotificationToastRenderer.web.tsx

@@ -0,0 +1,61 @@
+import * as React from "react";
+
+import { notificationToastManager } from "./NotificationToastManager";
+import { useNotificationToastState } from "./useNotificationToastState";
+
+const styles: Record<string, React.CSSProperties> = {
+  body: {
+    position: "absolute",
+    bottom: 0,
+    left: 0,
+    right: 0,
+    width: 1920,
+    height: 200,
+    background:
+      "linear-gradient(180deg, rgba(17,17,17,0.9) 0%, rgba(17,17,17,1) 49%, rgba(0,0,0,0.85) 100%)",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    flexDirection: "column",
+    color: "#fff",
+    paddingBottom: 15,
+  },
+  title: {
+    fontSize: 28,
+    margin: 0,
+    padding: 0,
+  },
+  subtitle: {
+    fontSize: 20,
+    margin: 0,
+    padding: 0,
+  },
+};
+
+export const NotificationToastRenderer = ({ children }) => {
+  const toast = useNotificationToastState();
+
+  return (
+    <div
+      data-testid="NotificationToastRenderer"
+      onClick={() => notificationToastManager.dismiss()}
+    >
+      {children}
+      {toast ? (
+        <div
+          data-testid="NotificationToastRenderer-touchable"
+          style={styles.body}
+        >
+          <div style={styles.title}>
+            <h2 data-testid="NotificationToastRenderer-message">
+              {toast.message}
+            </h2>
+          </div>
+          {toast.extraMessage ? (
+            <h4 style={styles.subtitle}>{toast.extraMessage}</h4>
+          ) : null}
+        </div>
+      ) : null}
+    </div>
+  );
+};

package/App/NotificationToastRenderer/__tests__/NotificationToastManager.test.ts

@@ -0,0 +1,213 @@
+import {
+  notificationToastManager,
+  NOTIFICATION_TOAST_EVENTS,
+} from "../NotificationToastManager";
+import { postEvent } from "@applicaster/zapp-react-native-utils/reactHooks/useSubscriberFor";
+
+jest.useFakeTimers();
+
+// notificationToastManager is a module-level singleton with a private
+// queue/isShowing/nextId, so every test must register its handlers through
+// `on()` (tracked below for cleanup) and fully drain the queue afterwards -
+// otherwise state leaks into the next test.
+describe("NotificationToastManager", () => {
+  let registered: Array<[string, (...args: any[]) => void]> = [];
+
+  const on = (event: string, handler: (...args: any[]) => void) => {
+    notificationToastManager.on(event, handler);
+    registered.push([event, handler]);
+  };
+
+  beforeAll(() => {
+    jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterAll(() => {
+    (console.log as jest.Mock).mockRestore();
+  });
+
+  afterEach(() => {
+    registered.forEach(([event, handler]) =>
+      notificationToastManager.removeHandler(event, handler)
+    );
+
+    registered = [];
+
+    // drain whatever is left showing/queued so the next test starts clean
+    notificationToastManager.reset();
+
+    jest.clearAllTimers();
+    jest.restoreAllMocks();
+    jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  it("emits SHOW with the toast payload when showToast is called", () => {
+    const onShow = jest.fn();
+    on(NOTIFICATION_TOAST_EVENTS.SHOW, onShow);
+
+    notificationToastManager.showToast({ id: "t1", message: "hello" });
+
+    expect(onShow).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "t1", message: "hello" }),
+      expect.any(Function)
+    );
+  });
+
+  it("auto-generates distinct ids for payloads that don't provide one", () => {
+    const onShow = jest.fn();
+    on(NOTIFICATION_TOAST_EVENTS.SHOW, onShow);
+
+    notificationToastManager.showToast({ message: "first" });
+    const firstId = onShow.mock.calls[0][0].id;
+
+    notificationToastManager.dismiss();
+
+    notificationToastManager.showToast({ message: "second" });
+    const secondId = onShow.mock.calls[1][0].id;
+
+    expect(typeof firstId).toBe("string");
+    expect(firstId).not.toEqual(secondId);
+  });
+
+  it("keeps a caller-provided id instead of generating one", () => {
+    const onShow = jest.fn();
+    on(NOTIFICATION_TOAST_EVENTS.SHOW, onShow);
+
+    notificationToastManager.showToast({ id: "custom-id", message: "hi" });
+
+    expect(onShow).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "custom-id" }),
+      expect.any(Function)
+    );
+  });
+
+  it("queues a second toast and shows it only after the first is dismissed", () => {
+    const onShow = jest.fn();
+    on(NOTIFICATION_TOAST_EVENTS.SHOW, onShow);
+
+    notificationToastManager.showToast({ id: "a", message: "first" });
+    notificationToastManager.showToast({ id: "b", message: "second" });
+
+    expect(onShow).toHaveBeenCalledTimes(1);
+
+    expect(onShow).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "a" }),
+      expect.any(Function)
+    );
+
+    notificationToastManager.dismiss();
+
+    expect(onShow).toHaveBeenCalledTimes(2);
+
+    expect(onShow).toHaveBeenLastCalledWith(
+      expect.objectContaining({ id: "b" }),
+      expect.any(Function)
+    );
+  });
+
+  it("auto-hides after the timeout and advances to the next queued toast", () => {
+    const onShow = jest.fn();
+    const onHide = jest.fn();
+    on(NOTIFICATION_TOAST_EVENTS.SHOW, onShow);
+    on(NOTIFICATION_TOAST_EVENTS.HIDE, onHide);
+
+    notificationToastManager.showToast({
+      id: "a",
+      message: "first",
+      timeout: 1000,
+    });
+
+    notificationToastManager.showToast({ id: "b", message: "second" });
+
+    jest.advanceTimersByTime(1000);
+
+    expect(onHide).toHaveBeenCalledTimes(1);
+
+    expect(onShow).toHaveBeenLastCalledWith(
+      expect.objectContaining({ id: "b" }),
+      expect.any(Function)
+    );
+  });
+
+  it("does nothing when dismiss is called with no toast showing", () => {
+    const onHide = jest.fn();
+    on(NOTIFICATION_TOAST_EVENTS.HIDE, onHide);
+
+    notificationToastManager.dismiss();
+
+    expect(onHide).not.toHaveBeenCalled();
+  });
+
+  it("updates a still-queued (not yet shown) toast in place instead of duplicating it", () => {
+    const onShow = jest.fn();
+    on(NOTIFICATION_TOAST_EVENTS.SHOW, onShow);
+
+    notificationToastManager.showToast({ id: "a", message: "first" });
+    notificationToastManager.showToast({ id: "b", message: "second" });
+    notificationToastManager.showToast({ id: "b", message: "second updated" });
+
+    notificationToastManager.dismiss();
+
+    expect(onShow).toHaveBeenCalledTimes(2);
+
+    expect(onShow).toHaveBeenLastCalledWith(
+      expect.objectContaining({ id: "b", message: "second updated" }),
+      expect.any(Function)
+    );
+  });
+
+  it("swaps the content of the currently visible toast when re-shown with the same id", () => {
+    const onShow = jest.fn();
+    on(NOTIFICATION_TOAST_EVENTS.SHOW, onShow);
+
+    notificationToastManager.showToast({
+      id: "a",
+      message: "first",
+      timeout: 5000,
+    });
+
+    notificationToastManager.showToast({ id: "a", message: "first updated" });
+
+    expect(onShow).toHaveBeenCalledTimes(2);
+
+    expect(onShow).toHaveBeenLastCalledWith(
+      expect.objectContaining({ id: "a", message: "first updated" }),
+      expect.any(Function)
+    );
+
+    // old timer must have been cleared, not still pending
+    jest.advanceTimersByTime(5000);
+    expect(onShow).toHaveBeenCalledTimes(2);
+  });
+
+  it("routes cross-package showToast events via the shared event bus", () => {
+    const onShow = jest.fn();
+    on(NOTIFICATION_TOAST_EVENTS.SHOW, onShow);
+
+    postEvent(NOTIFICATION_TOAST_EVENTS.SHOW_TOAST, [
+      { id: "bus", message: "from event bus" },
+    ]);
+
+    expect(onShow).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "bus", message: "from event bus" }),
+      expect.any(Function)
+    );
+  });
+
+  it("stops emitting to a handler after it has been removed", () => {
+    const onShow = jest.fn();
+    notificationToastManager.on(NOTIFICATION_TOAST_EVENTS.SHOW, onShow);
+
+    notificationToastManager.removeHandler(
+      NOTIFICATION_TOAST_EVENTS.SHOW,
+      onShow
+    );
+
+    notificationToastManager.showToast({
+      id: "removed-handler",
+      message: "hello",
+    });
+
+    expect(onShow).not.toHaveBeenCalled();
+  });
+});

package/App/NotificationToastRenderer/__tests__/NotificationToastRenderer.test.tsx

@@ -0,0 +1,85 @@
+import React from "react";
+import { Text } from "react-native";
+import { act, fireEvent, render } from "@testing-library/react-native";
+
+import { notificationToastManager } from "../NotificationToastManager";
+import { NotificationToastRenderer } from "../NotificationToastRenderer";
+
+jest.mock("react-native-safe-area-context", () => ({
+  useSafeAreaInsets: () => ({ top: 44 }),
+}));
+
+describe("NotificationToastRenderer", () => {
+  beforeAll(() => {
+    jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterAll(() => {
+    (console.log as jest.Mock).mockRestore();
+  });
+
+  afterEach(() => {
+    // drain whatever is left showing/queued so the next test starts clean
+    for (let i = 0; i < 10; i++) {
+      notificationToastManager.dismiss();
+    }
+
+    jest.restoreAllMocks();
+    jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  it("renders its children", () => {
+    const { getByText } = render(
+      <NotificationToastRenderer>
+        <Text>child content</Text>
+      </NotificationToastRenderer>
+    );
+
+    expect(getByText("child content")).toBeTruthy();
+  });
+
+  it("shows no message before any toast is emitted", () => {
+    const { getByTestId } = render(<NotificationToastRenderer />);
+
+    expect(
+      getByTestId("NotificationToastRenderer-message").props.children
+    ).toBeUndefined();
+  });
+
+  it("displays the message from a toast emitted by the manager", () => {
+    const { getByTestId } = render(<NotificationToastRenderer />);
+
+    act(() => {
+      notificationToastManager.showToast({ message: "You are offline" });
+    });
+
+    expect(
+      getByTestId("NotificationToastRenderer-message").props.children
+    ).toBe("You are offline");
+  });
+
+  it("applies the toast's style to the message text", () => {
+    const { getByTestId } = render(<NotificationToastRenderer />);
+
+    act(() => {
+      notificationToastManager.showToast({
+        message: "styled",
+        style: { color: "#123456", fontSize: 20 },
+      });
+    });
+
+    expect(
+      getByTestId("NotificationToastRenderer-message").props.style
+    ).toEqual(expect.objectContaining({ color: "#123456", fontSize: 20 }));
+  });
+
+  it("dismisses the toast when the touchable area is pressed", () => {
+    const dismissSpy = jest.spyOn(notificationToastManager, "dismiss");
+
+    const { getByTestId } = render(<NotificationToastRenderer />);
+
+    fireEvent.press(getByTestId("NotificationToastRenderer-touchable"));
+
+    expect(dismissSpy).toHaveBeenCalled();
+  });
+});

package/App/NotificationToastRenderer/__tests__/NotificationToastRenderer.web.test.tsx

@@ -0,0 +1,90 @@
+import React from "react";
+import { Text } from "react-native";
+import TestRenderer, { act } from "react-test-renderer";
+
+import { notificationToastManager } from "../NotificationToastManager";
+import { NotificationToastRenderer } from "../NotificationToastRenderer.web";
+
+// This variant renders plain DOM tags (div/h2/h4) for web, which
+// @testing-library/react-native's `render` cannot host-detect, so it is
+// exercised directly with react-test-renderer instead.
+describe("NotificationToastRenderer (web)", () => {
+  beforeAll(() => {
+    jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterAll(() => {
+    (console.log as jest.Mock).mockRestore();
+  });
+
+  afterEach(() => {
+    for (let i = 0; i < 10; i++) {
+      notificationToastManager.dismiss();
+    }
+
+    jest.restoreAllMocks();
+    jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  const createRenderer = (element: React.ReactElement) => {
+    let renderer;
+
+    act(() => {
+      renderer = TestRenderer.create(element);
+    });
+
+    return renderer;
+  };
+
+  it("renders its children", () => {
+    const renderer = createRenderer(
+      <NotificationToastRenderer>
+        <Text>child content</Text>
+      </NotificationToastRenderer>
+    );
+
+    expect(renderer.root.findByType(Text).props.children).toBe("child content");
+  });
+
+  it("renders nothing for the toast body until a toast is shown", () => {
+    const renderer = createRenderer(<NotificationToastRenderer />);
+
+    expect(
+      renderer.root.findAll(
+        (node) =>
+          node.props["data-testid"] === "NotificationToastRenderer-touchable"
+      )
+    ).toHaveLength(0);
+  });
+
+  it("shows the toast message once the manager emits one", () => {
+    const renderer = createRenderer(<NotificationToastRenderer />);
+
+    act(() => {
+      notificationToastManager.showToast({ message: "You are offline" });
+    });
+
+    const message = renderer.root.find(
+      (node) =>
+        node.props["data-testid"] === "NotificationToastRenderer-message"
+    );
+
+    expect(message.props.children).toBe("You are offline");
+  });
+
+  it("dismisses the toast when the root element is clicked", () => {
+    const dismissSpy = jest.spyOn(notificationToastManager, "dismiss");
+
+    const renderer = createRenderer(<NotificationToastRenderer />);
+
+    const root = renderer.root.find(
+      (node) => node.props["data-testid"] === "NotificationToastRenderer"
+    );
+
+    act(() => {
+      root.props.onClick();
+    });
+
+    expect(dismissSpy).toHaveBeenCalled();
+  });
+});

package/App/NotificationToastRenderer/__tests__/useNotificationHeight.test.tsx

@@ -0,0 +1,53 @@
+import { renderHook } from "@testing-library/react-native";
+
+let mockInsets = { top: 0 };
+
+jest.mock("react-native-safe-area-context", () => ({
+  useSafeAreaInsets: () => mockInsets,
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/reactUtils", () => ({
+  ...jest.requireActual("@applicaster/zapp-react-native-utils/reactUtils"),
+  platformSelect: jest.fn(({ ios, android }) => ({ ios, android })),
+}));
+
+import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { useNotificationHeight } from "../useNotificationHeight";
+
+describe("useNotificationHeight", () => {
+  beforeEach(() => {
+    (platformSelect as jest.Mock).mockClear();
+  });
+
+  it("adds the safe area top inset to the platform nav bar height", () => {
+    mockInsets = { top: 44 };
+    (platformSelect as jest.Mock).mockReturnValueOnce(56);
+
+    const { result } = renderHook(() => useNotificationHeight());
+
+    expect(result.current).toEqual({
+      statusHeight: 44,
+      notificationHeight: 100,
+    });
+  });
+
+  it("falls back to a 0 status height when there is no top inset", () => {
+    mockInsets = { top: 0 };
+    (platformSelect as jest.Mock).mockReturnValueOnce(44);
+
+    const { result } = renderHook(() => useNotificationHeight());
+
+    expect(result.current).toEqual({
+      statusHeight: 0,
+      notificationHeight: 44,
+    });
+  });
+
+  it("selects the nav bar height per platform via platformSelect", () => {
+    mockInsets = { top: 20 };
+
+    renderHook(() => useNotificationHeight());
+
+    expect(platformSelect).toHaveBeenCalledWith({ ios: 44, android: 56 });
+  });
+});

package/App/NotificationToastRenderer/__tests__/useNotificationToastState.test.ts

@@ -0,0 +1,112 @@
+import { act, renderHook } from "@testing-library/react-native";
+
+import { notificationToastManager } from "../NotificationToastManager";
+import { useNotificationToastState } from "../useNotificationToastState";
+
+jest.useFakeTimers();
+
+describe("useNotificationToastState", () => {
+  beforeAll(() => {
+    jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterAll(() => {
+    (console.log as jest.Mock).mockRestore();
+  });
+
+  afterEach(() => {
+    // drain whatever is left showing/queued so the next test starts clean;
+    // the hook's own effect cleanup (on unmount) removes its SHOW/HIDE
+    // handlers automatically via RNTL's auto-cleanup.
+    for (let i = 0; i < 10; i++) {
+      notificationToastManager.dismiss();
+    }
+
+    jest.restoreAllMocks();
+    jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  it("starts with no toast", () => {
+    const { result } = renderHook(() => useNotificationToastState());
+
+    expect(result.current).toBeNull();
+  });
+
+  it("reflects the toast emitted by the manager's SHOW event", () => {
+    const { result } = renderHook(() => useNotificationToastState());
+
+    act(() => {
+      notificationToastManager.showToast({ message: "hello" });
+    });
+
+    expect(result.current).toEqual(
+      expect.objectContaining({ message: "hello" })
+    );
+  });
+
+  it("clears the toast when the manager emits HIDE", () => {
+    const { result } = renderHook(() => useNotificationToastState());
+
+    act(() => {
+      notificationToastManager.showToast({ message: "hello" });
+    });
+
+    expect(result.current).not.toBeNull();
+
+    act(() => {
+      notificationToastManager.dismiss();
+    });
+
+    expect(result.current).toBeNull();
+  });
+
+  it("stops updating after unmount", () => {
+    const { result, unmount } = renderHook(() => useNotificationToastState());
+
+    unmount();
+
+    act(() => {
+      notificationToastManager.showToast({ message: "after unmount" });
+    });
+
+    expect(result.current).toBeNull();
+  });
+
+  it("subscribes on mount and disposes the subscription on unmount", () => {
+    const dispose = jest.fn();
+
+    const subscribeSpy = jest
+      .spyOn(notificationToastManager, "subscribe")
+      .mockReturnValue(dispose);
+
+    const { unmount } = renderHook(() => useNotificationToastState());
+
+    expect(subscribeSpy).toHaveBeenCalledWith(expect.any(Function));
+    expect(dispose).not.toHaveBeenCalled();
+
+    unmount();
+
+    expect(dispose).toHaveBeenCalledTimes(1);
+  });
+
+  it("subscribe registers SHOW/HIDE handlers and its disposer removes them", () => {
+    const callback = jest.fn();
+
+    const dispose = notificationToastManager.subscribe(callback);
+
+    act(() => {
+      notificationToastManager.showToast({ message: "hello" }); // emits SHOW
+    });
+
+    expect(callback).toHaveBeenCalled();
+
+    callback.mockClear();
+    dispose();
+
+    act(() => {
+      notificationToastManager.showToast({ message: "again" }); // emits SHOW
+    });
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/App/NotificationToastRenderer/index.tsx

@@ -0,0 +1,5 @@
+export { notificationToastManager } from "./NotificationToastManager";
+
+export { NotificationToastRenderer } from "./NotificationToastRenderer";
+
+export { useNotificationHeight } from "./useNotificationHeight";

package/App/NotificationToastRenderer/useNotificationHeight.tsx

@@ -0,0 +1,14 @@
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
+
+export const useNotificationHeight = () => {
+  const insets = useSafeAreaInsets();
+
+  const navBarHeight = platformSelect({ ios: 44, android: 56 });
+
+  const statusHeight = insets.top;
+  const notificationHeight = statusHeight + navBarHeight;
+
+  return { statusHeight, notificationHeight };
+};

package/App/NotificationToastRenderer/useNotificationToastState.tsx

@@ -0,0 +1,12 @@
+import * as React from "react";
+
+import { notificationToastManager } from "./NotificationToastManager";
+
+export const useNotificationToastState = () => {
+  const state = React.useSyncExternalStore(
+    notificationToastManager.subscribe,
+    notificationToastManager.getCurrentState
+  );
+
+  return state;
+};

package/App/index.tsx

@@ -31,6 +31,7 @@ import { withActionExecutor } from "@applicaster/zapp-react-native-utils/actions
 import { withScreenDataContextProvider } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenDataContext";
 import { LogicAggregatorContainer } from "./LogicAggregatorContainer";
 import { LoadingOverlay } from "./LoadingOverlay";
+import { NotificationToastRenderer } from "./NotificationToastRenderer";
 import { ZappAppWrapper } from "./components/ZappAppWrapper";
 
 interface AppOptions {
@@ -67,11 +68,13 @@ const App = ({
               <ErrorBoundary>
                 <URLSchemeListener>
                   <SplashLoader>
-                    <OfflineHandler>
-                      <Layout>
-                        <RouteManager />
-                      </Layout>
-                    </OfflineHandler>
+                    <NotificationToastRenderer>
+                      <OfflineHandler>
+                        <Layout>
+                          <RouteManager />
+                        </Layout>
+                      </OfflineHandler>
+                    </NotificationToastRenderer>
                   </SplashLoader>
                   <ModalProvider />
                 </URLSchemeListener>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/quick-brick-core",
-  "version": "16.0.0-alpha.9534912292",
+  "version": "16.0.0-alpha.9739533780",
   "description": "Core package for Applicaster's Quick Brick App",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,13 +28,13 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "16.0.0-alpha.9534912292",
-    "@applicaster/quick-brick-core-plugins": "16.0.0-alpha.9534912292",
-    "@applicaster/zapp-pipes-v2-client": "16.0.0-alpha.9534912292",
-    "@applicaster/zapp-react-native-bridge": "16.0.0-alpha.9534912292",
-    "@applicaster/zapp-react-native-redux": "16.0.0-alpha.9534912292",
-    "@applicaster/zapp-react-native-ui-components": "16.0.0-alpha.9534912292",
-    "@applicaster/zapp-react-native-utils": "16.0.0-alpha.9534912292",
+    "@applicaster/applicaster-types": "16.0.0-alpha.9739533780",
+    "@applicaster/quick-brick-core-plugins": "16.0.0-alpha.9739533780",
+    "@applicaster/zapp-pipes-v2-client": "16.0.0-alpha.9739533780",
+    "@applicaster/zapp-react-native-bridge": "16.0.0-alpha.9739533780",
+    "@applicaster/zapp-react-native-redux": "16.0.0-alpha.9739533780",
+    "@applicaster/zapp-react-native-ui-components": "16.0.0-alpha.9739533780",
+    "@applicaster/zapp-react-native-utils": "16.0.0-alpha.9739533780",
     "atob": "^2.1.2",
     "axios": "^0.28.0",
     "btoa": "^1.2.1",