@applicaster/quick-brick-core 16.0.0-rc.9 → 16.0.0-rc.90

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

@@ -0,0 +1,233 @@
+import React from "react";
+import { Text } from "react-native";
+import { act, fireEvent, render } from "@testing-library/react-native";
+import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
+
+import {
+  CONFIRMATION_TOAST_SOURCE,
+  notificationToastManager,
+} from "../NotificationToastManager";
+import { NotificationToastRenderer } from "../NotificationToastRenderer";
+
+jest.mock("react-native-safe-area-context", () => ({
+  useSafeAreaInsets: () => ({ top: 44 }),
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/theme", () => ({
+  useTheme: jest.fn(),
+}));
+
+jest.mock("react-native-gesture-handler", () => {
+  const RN = require("react-native");
+  const ReactActual = require("react");
+  const actual = jest.requireActual("react-native-gesture-handler");
+
+  const GestureDetector = ReactActual.forwardRef(
+    ({ gesture, children }: any, ref: any) => {
+      const onEnd = gesture?.handlers?.onEnd;
+
+      return (
+        <RN.View
+          ref={ref}
+          testID="NotificationToastRenderer-fling-handler"
+          accessibilityState={{ disabled: gesture?.config?.enabled === false }}
+          // drive Gesture.Fling().onEnd via a test-only event
+          onEnd={() => onEnd?.({}, true)}
+          onEndFailed={() => onEnd?.({}, false)}
+        >
+          {children}
+        </RN.View>
+      );
+    }
+  );
+
+  return {
+    __esModule: true,
+    ...actual,
+    GestureDetector,
+  };
+});
+
+const mockedUseTheme = useTheme as jest.MockedFunction<typeof useTheme>;
+
+const confirmationTheme: Partial<BaseThemePropertiesMobile> = {
+  confirmation_toast_style_background_color: "#0188FF",
+  confirmation_toast_style_color: "#EFEFEF",
+  confirmation_toast_style_ios_font_family: "SFProText-Semibold",
+  confirmation_toast_style_android_font_family: "Roboto-Medium",
+  confirmation_toast_style_ios_font_size: 14,
+  confirmation_toast_style_android_font_size: 14,
+  confirmation_toast_style_ios_line_height: 44,
+  confirmation_toast_style_android_line_height: 44,
+  confirmation_toast_style_ios_letter_spacing: -1.4,
+  confirmation_toast_style_android_letter_spacing: -1.4,
+};
+
+describe("NotificationToastRenderer", () => {
+  beforeAll(() => {
+    jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterAll(() => {
+    (console.log as jest.Mock).mockRestore();
+  });
+
+  beforeEach(() => {
+    mockedUseTheme.mockReturnValue(
+      confirmationTheme as BaseThemePropertiesMobile
+    );
+  });
+
+  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("applies Theme confirmation styles when source is confirmation", () => {
+    const { getByTestId } = render(<NotificationToastRenderer />);
+
+    act(() => {
+      notificationToastManager.showToast({
+        message: "Added to queue",
+        source: CONFIRMATION_TOAST_SOURCE,
+      });
+    });
+
+    expect(
+      getByTestId("NotificationToastRenderer-message").props.style
+    ).toEqual(
+      expect.objectContaining({
+        color: "#EFEFEF",
+        fontSize: 14,
+        lineHeight: 44,
+        letterSpacing: -1.4,
+      })
+    );
+  });
+
+  it("shallow-merges style overrides onto Theme confirmation defaults", () => {
+    const { getByTestId } = render(<NotificationToastRenderer />);
+
+    act(() => {
+      notificationToastManager.showToast({
+        message: "Playlist created",
+        source: CONFIRMATION_TOAST_SOURCE,
+        style: { backgroundColor: "#00FF00", fontSize: 20 },
+      });
+    });
+
+    expect(
+      getByTestId("NotificationToastRenderer-message").props.style
+    ).toEqual(
+      expect.objectContaining({
+        color: "#EFEFEF",
+        fontSize: 20,
+        lineHeight: 44,
+      })
+    );
+  });
+
+  it("does not apply Theme confirmation styles for non-confirmation toasts", () => {
+    const { getByTestId } = render(<NotificationToastRenderer />);
+
+    act(() => {
+      notificationToastManager.showToast({
+        message: "You are offline",
+        style: { color: "#abcdef" },
+      });
+    });
+
+    expect(
+      getByTestId("NotificationToastRenderer-message").props.style
+    ).toEqual(
+      expect.objectContaining({
+        color: "#abcdef",
+      })
+    );
+
+    expect(
+      getByTestId("NotificationToastRenderer-message").props.style.fontSize
+    ).toBeUndefined();
+  });
+
+  it("dismisses the toast on a successful upward fling", () => {
+    const dismissSpy = jest.spyOn(notificationToastManager, "dismiss");
+
+    const { getByTestId } = render(<NotificationToastRenderer />);
+
+    act(() => {
+      notificationToastManager.showToast({ message: "Added to queue" });
+    });
+
+    fireEvent(getByTestId("NotificationToastRenderer-fling-handler"), "end");
+
+    expect(dismissSpy).toHaveBeenCalled();
+  });
+
+  it("does not dismiss when the fling ends unsuccessfully", () => {
+    const dismissSpy = jest.spyOn(notificationToastManager, "dismiss");
+
+    const { getByTestId } = render(<NotificationToastRenderer />);
+
+    act(() => {
+      notificationToastManager.showToast({ message: "Added to queue" });
+    });
+
+    fireEvent(
+      getByTestId("NotificationToastRenderer-fling-handler"),
+      "endFailed"
+    );
+
+    expect(dismissSpy).not.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__/resolveConfirmationToastStyle.test.ts

@@ -0,0 +1,118 @@
+import { resolveConfirmationToastStyle } from "../resolveConfirmationToastStyle";
+
+jest.mock("@applicaster/zapp-react-native-utils/reactUtils", () => ({
+  // manifestKeyParser captures currentPlatform at module load from this map
+  platformSelect: jest.fn((platforms) => {
+    if (platforms?.ios === "ios" && platforms?.android === "android") {
+      return "ios";
+    }
+
+    return platforms?.default;
+  }),
+}));
+
+describe("resolveConfirmationToastStyle", () => {
+  const theme = {
+    confirmation_toast_style_background_color: "#0188FF",
+    confirmation_toast_style_color: "#EFEFEF",
+    confirmation_toast_style_ios_font_family: "SFProText-Semibold",
+    confirmation_toast_style_android_font_family: "Roboto-Medium",
+    confirmation_toast_style_ios_font_size: 14,
+    confirmation_toast_style_android_font_size: 16,
+    confirmation_toast_style_ios_line_height: 44,
+    confirmation_toast_style_android_line_height: 40,
+    confirmation_toast_style_ios_letter_spacing: -1.4,
+    confirmation_toast_style_android_letter_spacing: -0.5,
+  };
+
+  it("maps Theme confirmation_toast_style_* keys via getAllSpecificStyles (iOS platform)", () => {
+    expect(resolveConfirmationToastStyle(theme)).toEqual({
+      backgroundColor: "#0188FF",
+      color: "#EFEFEF",
+      fontFamily: "SFProText-Semibold",
+      fontSize: 14,
+      lineHeight: 44,
+      letterSpacing: -1.4,
+    });
+  });
+
+  it("ignores other-platform keys for the current platform", () => {
+    const result = resolveConfirmationToastStyle(theme);
+
+    expect(result.fontFamily).toBe("SFProText-Semibold");
+    expect(result.fontSize).toBe(14);
+
+    expect(result).not.toEqual(
+      expect.objectContaining({
+        fontFamily: "Roboto-Medium",
+        fontSize: 16,
+      })
+    );
+  });
+
+  it("shallow-merges override style on top of Theme defaults", () => {
+    expect(
+      resolveConfirmationToastStyle(theme, {
+        backgroundColor: "#00FF00",
+        fontSize: 20,
+      })
+    ).toEqual({
+      backgroundColor: "#00FF00",
+      color: "#EFEFEF",
+      fontFamily: "SFProText-Semibold",
+      fontSize: 20,
+      lineHeight: 44,
+      letterSpacing: -1.4,
+    });
+  });
+
+  it("returns override fields when Theme is missing", () => {
+    expect(resolveConfirmationToastStyle(undefined, { color: "#fff" })).toEqual(
+      {
+        color: "#fff",
+      }
+    );
+  });
+});
+
+describe("resolveConfirmationToastStyle (android platform)", () => {
+  it("maps android platform Theme keys", () => {
+    jest.resetModules();
+
+    jest.doMock("@applicaster/zapp-react-native-utils/reactUtils", () => ({
+      platformSelect: jest.fn((platforms) => {
+        if (platforms?.ios === "ios" && platforms?.android === "android") {
+          return "android";
+        }
+
+        return platforms?.default;
+      }),
+    }));
+
+    const {
+      resolveConfirmationToastStyle: resolveAndroid,
+    } = require("../resolveConfirmationToastStyle");
+
+    const theme = {
+      confirmation_toast_style_background_color: "#0188FF",
+      confirmation_toast_style_color: "#EFEFEF",
+      confirmation_toast_style_ios_font_family: "SFProText-Semibold",
+      confirmation_toast_style_android_font_family: "Roboto-Medium",
+      confirmation_toast_style_ios_font_size: 14,
+      confirmation_toast_style_android_font_size: 16,
+      confirmation_toast_style_ios_line_height: 44,
+      confirmation_toast_style_android_line_height: 40,
+      confirmation_toast_style_ios_letter_spacing: -1.4,
+      confirmation_toast_style_android_letter_spacing: -0.5,
+    };
+
+    expect(resolveAndroid(theme)).toEqual({
+      backgroundColor: "#0188FF",
+      color: "#EFEFEF",
+      fontFamily: "Roboto-Medium",
+      fontSize: 16,
+      lineHeight: 40,
+      letterSpacing: -0.5,
+    });
+  });
+});

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

@@ -0,0 +1,58 @@
+import { renderHook } from "@testing-library/react-native";
+
+let mockInsets = { top: 0 };
+const mockGetNavbarHeight = jest.fn();
+
+jest.mock("react-native-safe-area-context", () => ({
+  useSafeAreaInsets: () => mockInsets,
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/layout", () => ({
+  getNavbarHeight: () => mockGetNavbarHeight(),
+}));
+
+import { useNotificationHeight } from "../useNotificationHeight";
+
+describe("useNotificationHeight", () => {
+  beforeEach(() => {
+    mockGetNavbarHeight.mockClear();
+  });
+
+  it("adds the safe area top inset to the nav bar height", () => {
+    mockInsets = { top: 44 };
+    mockGetNavbarHeight.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 };
+    mockGetNavbarHeight.mockReturnValueOnce(44);
+
+    const { result } = renderHook(() => useNotificationHeight());
+
+    expect(result.current).toEqual({
+      statusHeight: 0,
+      notificationHeight: 44,
+    });
+  });
+
+  it("uses getNavbarHeight for the nav bar height", () => {
+    mockInsets = { top: 20 };
+    mockGetNavbarHeight.mockReturnValueOnce(56);
+
+    const { result } = renderHook(() => useNotificationHeight());
+
+    expect(mockGetNavbarHeight).toHaveBeenCalled();
+
+    expect(result.current).toEqual({
+      statusHeight: 20,
+      notificationHeight: 76,
+    });
+  });
+});

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,9 @@
+export { notificationToastManager } from "./NotificationToastManager";
+
+export type { ToastPayload, ToastStyle } from "./NotificationToastManager";
+
+export { CONFIRMATION_TOAST_SOURCE } from "./NotificationToastManager";
+
+export { NotificationToastRenderer } from "./NotificationToastRenderer";
+
+export { resolveConfirmationToastStyle } from "./resolveConfirmationToastStyle";

package/App/NotificationToastRenderer/resolveConfirmationToastStyle.ts

@@ -0,0 +1,33 @@
+import { getAllSpecificStyles } from "@applicaster/zapp-react-native-utils/configurationUtils/manifestKeyParser";
+
+import { ToastStyle } from "./NotificationToastManager";
+
+const CONFIRMATION_TOAST_STYLE_COMPONENT = "confirmation_toast";
+
+/**
+ * Builds confirmation-toast style from Theme defaults via getAllSpecificStyles,
+ * then shallow-merges any caller override on top.
+ *
+ * Expected Theme keys follow:
+ * `confirmation_toast_style_[platform_]<style_name>`
+ * e.g. confirmation_toast_style_background_color,
+ *      confirmation_toast_style_ios_font_family
+ */
+export function resolveConfirmationToastStyle(
+  theme: Partial<BaseThemePropertiesMobile> | null | undefined,
+  overrideStyle?: ToastStyle | null
+): ToastStyle {
+  const outStyles: Record<string, ToastStyle> = {};
+
+  getAllSpecificStyles({
+    configuration: { ...(theme ?? {}) },
+    componentName: CONFIRMATION_TOAST_STYLE_COMPONENT,
+    subComponentName: "",
+    outStyles,
+  });
+
+  return {
+    ...outStyles.default,
+    ...overrideStyle,
+  };
+}

package/App/NotificationToastRenderer/useNotificationHeight.tsx

@@ -0,0 +1,14 @@
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+import { getNavbarHeight } from "@applicaster/zapp-react-native-utils/reactHooks/layout";
+
+/** Hook calculates the height of the notification area including the status bar and navigation bar, used only for mobile */
+export const useNotificationHeight = () => {
+  const insets = useSafeAreaInsets();
+
+  const navBarHeight = getNavbarHeight();
+
+  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;
+};