@applicaster/quick-brick-core 16.0.0-rc.99 → 17.0.0-rc.1

package/App/layoutPreview/__tests__/persistence.test.ts

@@ -0,0 +1,63 @@
+import { NativeModules } from "react-native";
+
+import {
+  SUPPRESSION_MS,
+  applyPersistedLayoutPreview,
+  leavePreviewForDefault,
+  shouldKeepOverride,
+  shouldShowReminder,
+} from "../persistence";
+
+const mockStore: Record<string, string> = {};
+
+jest.mock(
+  "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage",
+  () => ({
+    localStorage: {
+      getItem: async (key: string) => mockStore[key] ?? null,
+      setItem: async (key: string, value: string) => {
+        mockStore[key] = value;
+      },
+      removeItem: async (key: string) => {
+        delete mockStore[key];
+      },
+    },
+  })
+);
+
+describe("layout preview persistence", () => {
+  it("keeps a non-default layout id and drops the version default", () => {
+    expect(shouldKeepOverride("preview", "default")).toBe(true);
+    expect(shouldKeepOverride("default", "default")).toBe(false);
+    expect(shouldKeepOverride(null, "default")).toBe(false);
+    expect(shouldKeepOverride("preview", null)).toBe(true);
+  });
+
+  it("suppresses the reminder for two hours after acknowledgment", () => {
+    const now = 1_000_000;
+
+    expect(shouldShowReminder(true, null, now)).toBe(true);
+    expect(shouldShowReminder(false, null, now)).toBe(false);
+
+    expect(shouldShowReminder(true, now - SUPPRESSION_MS + 1, now)).toBe(false);
+
+    expect(shouldShowReminder(true, now - SUPPRESSION_MS, now)).toBe(true);
+  });
+
+  it("keeps the version default for exactly one load after Back to Default", async () => {
+    const switchLayout = jest.fn(async () => true);
+
+    NativeModules.AppLoaderBridge = {
+      getDefaultLayoutId: async () => "default",
+      switchLayout,
+    };
+
+    mockStore.layout_preview_id = "preview";
+
+    await leavePreviewForDefault();
+
+    expect(await applyPersistedLayoutPreview()).toBe("default");
+    expect(switchLayout).toHaveBeenLastCalledWith("default", null);
+    expect(await applyPersistedLayoutPreview()).toBe("absent");
+  });
+});

package/App/layoutPreview/persistence.ts

@@ -0,0 +1,228 @@
+import { NativeModules } from "react-native";
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+
+// Separate from active_layout_id, which the switchLayout action owns.
+export const LAYOUT_PREVIEW_ID_KEY = "layout_preview_id";
+
+export const LAYOUT_PREVIEW_ACK_KEY = "layout_preview_ack_at";
+
+// Set by Back to Default; makes the reload that follows skip layout selectors once.
+export const LAYOUT_PREVIEW_RESTORE_DEFAULT_KEY =
+  "layout_preview_restore_default";
+
+export const SUPPRESSION_MS = 2 * 60 * 60 * 1000;
+
+export const PREVIEW_TITLE = "You're Viewing a Preview Layout";
+
+export const PREVIEW_MESSAGE =
+  "This device is currently displaying a preview layout instead of the version default layout.";
+
+export const PREVIEW_CONTINUE = "Continue Preview";
+
+export const PREVIEW_BACK = "Back to Default Layout";
+
+export const UNAVAILABLE_TITLE = "Preview layout unavailable";
+
+export const UNAVAILABLE_MESSAGE =
+  "This device was returned to the version default layout.";
+
+export type PreviewApplyResult = "applied" | "absent" | "invalid" | "default";
+
+let unavailableNotice = false;
+
+export function shouldKeepOverride(
+  layoutId: string | null | undefined,
+  defaultId: string | null | undefined
+): boolean {
+  return Boolean(layoutId) && layoutId !== defaultId;
+}
+
+export function shouldShowReminder(
+  hasOverride: boolean,
+  ackAt: number | null,
+  now: number
+): boolean {
+  if (!hasOverride) return false;
+  if (ackAt == null || Number.isNaN(ackAt)) return true;
+
+  return now - ackAt >= SUPPRESSION_MS;
+}
+
+export function markPreviewUnavailable(): void {
+  unavailableNotice = true;
+}
+
+export function consumePreviewUnavailable(): boolean {
+  const pending = unavailableNotice;
+  unavailableNotice = false;
+
+  return pending;
+}
+
+async function removeKey(key: string): Promise<void> {
+  try {
+    await localStorage.removeItem(key);
+  } catch {
+    // key was already absent
+  }
+}
+
+async function readOverrideId(): Promise<string | null> {
+  try {
+    const id = await localStorage.getItem(LAYOUT_PREVIEW_ID_KEY);
+
+    return id || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function getDefaultLayoutId(): Promise<string | null> {
+  try {
+    const id = await NativeModules.AppLoaderBridge?.getDefaultLayoutId?.();
+
+    return id || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function clearLayoutPreview(): Promise<void> {
+  await removeKey(LAYOUT_PREVIEW_ID_KEY);
+  await removeKey(LAYOUT_PREVIEW_ACK_KEY);
+}
+
+/**
+ * Drops the pin and points the loader at the version default.
+ * Used by Back to Default and by a preview link that targets the default layout.
+ */
+export async function returnToDefaultLayout(): Promise<void> {
+  const defaultId = await getDefaultLayoutId();
+
+  await clearLayoutPreview();
+
+  if (!defaultId || !NativeModules.AppLoaderBridge?.switchLayout) return;
+
+  try {
+    await NativeModules.AppLoaderBridge.switchLayout(defaultId, null);
+  } catch {
+    // the pin is already gone; the next load uses the version default
+  }
+}
+
+/** Back to Default from the reminder. The app reloads next, and that load must stay on the version default. */
+export async function leavePreviewForDefault(): Promise<void> {
+  await localStorage.setItem(LAYOUT_PREVIEW_RESTORE_DEFAULT_KEY, "true");
+  await returnToDefaultLayout();
+}
+
+/** Same as returnToDefaultLayout, plus a one-shot unavailable notice. */
+export async function restoreInvalidPreview(): Promise<void> {
+  markPreviewUnavailable();
+  await returnToDefaultLayout();
+}
+
+/**
+ * Pins a layout id, or clears the pin when the id is the version default.
+ * A storage failure still leaves the in-session preview in place.
+ */
+export async function rememberLayoutPreview(layoutId: string): Promise<void> {
+  if (!layoutId) return;
+
+  try {
+    const defaultId = await getDefaultLayoutId();
+
+    if (!shouldKeepOverride(layoutId, defaultId)) {
+      await returnToDefaultLayout();
+
+      return;
+    }
+
+    const current = await readOverrideId();
+
+    if (current !== layoutId) {
+      await removeKey(LAYOUT_PREVIEW_ACK_KEY);
+    }
+
+    await localStorage.setItem(LAYOUT_PREVIEW_ID_KEY, layoutId);
+  } catch {
+    // this session already loaded the layout; the pin is best-effort
+  }
+}
+
+export async function acknowledgeLayoutPreview(): Promise<void> {
+  await localStorage.setItem(LAYOUT_PREVIEW_ACK_KEY, String(Date.now()));
+}
+
+export async function readReminderState(): Promise<{
+  hasOverride: boolean;
+  ackAt: number | null;
+}> {
+  const layoutId = await readOverrideId();
+  const defaultId = await getDefaultLayoutId();
+  let ackRaw: string | null = null;
+
+  try {
+    ackRaw = await localStorage.getItem(LAYOUT_PREVIEW_ACK_KEY);
+  } catch {
+    ackRaw = null;
+  }
+
+  const ackAt = ackRaw == null || ackRaw === "" ? null : Number(ackRaw);
+
+  return {
+    hasOverride: shouldKeepOverride(layoutId, defaultId),
+    ackAt: ackAt != null && !Number.isNaN(ackAt) ? ackAt : null,
+  };
+}
+
+/**
+ * Re-applies a stored preview before layout-manager selection.
+ * "invalid" means the pin was cleared and the version default was restored,
+ * so the caller must not run selectLayout over the top of that fallback.
+ */
+export async function applyPersistedLayoutPreview(): Promise<PreviewApplyResult> {
+  let restoreDefault = null;
+
+  try {
+    restoreDefault = await localStorage.getItem(
+      LAYOUT_PREVIEW_RESTORE_DEFAULT_KEY
+    );
+  } catch {
+    restoreDefault = null;
+  }
+
+  if (restoreDefault) {
+    await removeKey(LAYOUT_PREVIEW_RESTORE_DEFAULT_KEY);
+
+    const defaultId = await getDefaultLayoutId();
+
+    if (defaultId) {
+      await NativeModules.AppLoaderBridge.switchLayout(defaultId, null);
+    }
+
+    return "default";
+  }
+
+  const layoutId = await readOverrideId();
+
+  if (!layoutId) return "absent";
+
+  const defaultId = await getDefaultLayoutId();
+
+  if (!shouldKeepOverride(layoutId, defaultId)) {
+    await clearLayoutPreview();
+
+    return "absent";
+  }
+
+  try {
+    await NativeModules.AppLoaderBridge.switchLayout(layoutId, null);
+
+    return "applied";
+  } catch {
+    await restoreInvalidPreview();
+
+    return "invalid";
+  }
+}

package/App/logger.js

@@ -1,3 +1,3 @@
-import { coreLogger } from "@applicaster/zapp-react-native-utils/logger";
+import { subsystemLogger } from "@applicaster/zapp-react-native-utils/logger";
 
-export const coreAppLogger = coreLogger.addSubsystem("app");
+export const coreAppLogger = subsystemLogger("app");

package/App/remoteContextReloader/__tests__/getNativeRemoteContextData.test.ts

@@ -0,0 +1,148 @@
+import { loadAppContextData } from "@applicaster/zapp-react-native-redux";
+import { getPromiseForType } from "../helpers";
+import {
+  applyPersistedLayoutPreview,
+  restoreInvalidPreview,
+} from "../../layoutPreview/persistence";
+import { getNativeRemoteContextData } from "../getRemoteContextData/getNativeRemoteContextData";
+
+jest.mock("@applicaster/zapp-react-native-redux", () => ({
+  ...jest.requireActual("@applicaster/zapp-react-native-redux"),
+  loadAppContextData: jest.fn(),
+}));
+
+jest.mock("../helpers", () => ({
+  getPromiseForType: jest.fn(),
+  fetchPluginConfiguration: () => (plugin) => plugin,
+}));
+
+jest.mock("../../AssetCache", () => ({
+  cacheAssets: jest.fn(async (data) => data),
+}));
+
+jest.mock("../../layoutPreview/persistence", () => ({
+  applyPersistedLayoutPreview: jest.fn(),
+  restoreInvalidPreview: jest.fn(),
+}));
+
+const mockedGetPromiseForType = getPromiseForType as jest.Mock;
+
+const FILES = {
+  remoteConfigurations: { remoteConfigurations: {} },
+  pluginConfigurations: { pluginConfigurations: [] },
+  pipesEndpoints: { pipesEndpoints: {} },
+  layout: { layout: { api_version: "v2", content_types: {} } },
+  cellStyles: { cellStyles: { style: {} } },
+  presetsMapping: { presetsMapping: { preset: {} } },
+};
+
+const LAYOUT_FILES = ["layout", "cellStyles", "presetsMapping"];
+
+/** Holds every request open until the test releases it. */
+function deferredFiles(files = FILES) {
+  const pending: Record<string, () => void> = {};
+
+  mockedGetPromiseForType.mockImplementation(
+    (key: string) =>
+      new Promise((resolve, reject) => {
+        pending[key] = () =>
+          files[key] ? resolve(files[key]) : reject(new Error(key));
+      })
+  );
+
+  return pending;
+}
+
+/** Keys of the app context handed to the store on the final load. */
+const loadedKeys = () =>
+  Object.keys((loadAppContextData as jest.Mock).mock.calls.at(-1)[1]);
+
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+describe("getNativeRemoteContextData", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (applyPersistedLayoutPreview as jest.Mock).mockResolvedValue("absent");
+  });
+
+  it("requests the layout files together, not one after another", async () => {
+    const pending = deferredFiles();
+    const dispatch = jest.fn();
+
+    const done = getNativeRemoteContextData(dispatch, {}, []);
+
+    await flush();
+
+    ["remoteConfigurations", "pluginConfigurations", "pipesEndpoints"].forEach(
+      (key) => pending[key]()
+    );
+
+    await flush();
+
+    expect(Object.keys(pending)).toEqual(expect.arrayContaining(LAYOUT_FILES));
+
+    LAYOUT_FILES.forEach((key) => pending[key]());
+    await done;
+
+    expect(loadedKeys()).toEqual(
+      expect.arrayContaining(["rivers", "cellStyles", "presetsMapping"])
+    );
+  });
+
+  it("tolerates a missing presetsMapping", async () => {
+    const { presetsMapping: _presetsMapping, ...withoutPresets } = FILES;
+
+    mockedGetPromiseForType.mockImplementation(async (key: string) => {
+      if (!withoutPresets[key]) throw new Error(key);
+
+      return withoutPresets[key];
+    });
+
+    const dispatch = jest.fn();
+
+    await expect(
+      getNativeRemoteContextData(dispatch, {}, [])
+    ).resolves.toBeUndefined();
+
+    expect(loadedKeys()).toContain("rivers");
+    expect(loadedKeys()).not.toContain("presetsMapping");
+  });
+
+  it("rejects when cellStyles cannot be loaded", async () => {
+    const { cellStyles: _cellStyles, ...withoutCellStyles } = FILES;
+
+    mockedGetPromiseForType.mockImplementation(async (key: string) => {
+      if (!withoutCellStyles[key]) throw new Error(key);
+
+      return withoutCellStyles[key];
+    });
+
+    await expect(getNativeRemoteContextData(jest.fn(), {}, [])).rejects.toThrow(
+      "cellStyles"
+    );
+  });
+
+  it("refetches every layout file after restoring a broken preview", async () => {
+    (applyPersistedLayoutPreview as jest.Mock).mockResolvedValue("applied");
+
+    let restored = false;
+
+    (restoreInvalidPreview as jest.Mock).mockImplementation(async () => {
+      restored = true;
+    });
+
+    mockedGetPromiseForType.mockImplementation(async (key: string) => {
+      if (key === "layout" && !restored) throw new Error("preview layout");
+
+      return FILES[key];
+    });
+
+    await getNativeRemoteContextData(jest.fn(), {}, []);
+
+    const requests = mockedGetPromiseForType.mock.calls.map(([key]) => key);
+
+    LAYOUT_FILES.forEach((key) => {
+      expect(requests.filter((request) => request === key)).toHaveLength(2);
+    });
+  });
+});

package/App/remoteContextReloader/__tests__/getPromiseForType.test.js

@@ -0,0 +1,31 @@
+const { NativeModules } = require("react-native");
+
+NativeModules.AppLoaderBridge = { getFile: jest.fn() };
+
+const { getPromiseForType } = require("../helpers");
+
+const layout = { id: "layout", content_types: {} };
+
+describe("getPromiseForType", () => {
+  it("parses the JSON string native bridges resolve", async () => {
+    NativeModules.AppLoaderBridge.getFile.mockResolvedValue(
+      JSON.stringify(layout)
+    );
+
+    await expect(getPromiseForType("layout")).resolves.toEqual({ layout });
+  });
+
+  it("passes through the parsed file the web bridge resolves", async () => {
+    NativeModules.AppLoaderBridge.getFile.mockResolvedValue(layout);
+
+    await expect(getPromiseForType("layout")).resolves.toEqual({ layout });
+  });
+
+  it("rejects when the bridge fails", async () => {
+    NativeModules.AppLoaderBridge.getFile.mockRejectedValue(new Error("404"));
+
+    await expect(getPromiseForType("layout")).rejects.toThrow(
+      "cannot retrieve configuration data for layout"
+    );
+  });
+});

package/App/remoteContextReloader/getRemoteContextData/getNativeRemoteContextData.ts

@@ -1,5 +1,4 @@
 import * as R from "ramda";
-import isEmpty from "lodash/isEmpty";
 import { Dimensions, NativeModules } from "react-native";
 import {
   loadAppContextData,
@@ -7,6 +6,7 @@ import {
 } from "@applicaster/zapp-react-native-redux";
 import { isTablet } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { mapPromises } from "@applicaster/zapp-react-native-utils/arrayUtils";
+import { isEmpty } from "@applicaster/zapp-react-native-utils/utils";
 import { fetchPluginConfiguration, getPromiseForType } from "../helpers";
 import { cacheAssets } from "../../AssetCache";
 import { logger } from "@applicaster/zapp-react-native-utils/logger";
@@ -14,6 +14,83 @@ import { ACTIVE_LAYOUT_ID_STORAGE_KEY } from "../consts";
 const { AppLoaderBridge } = NativeModules;
 import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
 import { useErrorStore } from "../../ErrorBoundary/store";
+import {
+  PreviewApplyResult,
+  applyPersistedLayoutPreview,
+  restoreInvalidPreview,
+} from "../../layoutPreview/persistence";
+
+/**
+ * Points the loader at the layout to fetch. A persisted device preview wins
+ * over the layout-manager plugin (experiment, geo, language) and over active_layout_id.
+ */
+async function selectActiveLayout(
+  runtimeConfigurationUrls,
+  plugins,
+  isTabletDevice: boolean
+): Promise<PreviewApplyResult> {
+  let preview: PreviewApplyResult = "absent";
+
+  try {
+    preview = await applyPersistedLayoutPreview();
+
+    if (preview !== "absent") return preview;
+
+    const layoutManagerPlugin = R.find(
+      R.pathSatisfies(R.is(Function), ["module", "selectLayout"])
+    )(plugins);
+
+    if (layoutManagerPlugin) {
+      await layoutManagerPlugin.module?.selectLayout({
+        runtimeConfigurationUrls,
+        plugin: layoutManagerPlugin,
+        isTablet: isTabletDevice,
+      });
+
+      return preview;
+    }
+
+    const layoutId = await localStorage.getItem(ACTIVE_LAYOUT_ID_STORAGE_KEY);
+
+    if (layoutId) {
+      await AppLoaderBridge?.switchLayout(layoutId, null);
+    }
+  } catch (error) {
+    logger.error({
+      message: "Error selecting layout using layout manager plugin",
+      data: error,
+    });
+  }
+
+  return preview;
+}
+
+/**
+ * Fetches the files that belong to the selected layout. They all derive from
+ * the same layout id, so they are requested together rather than one round
+ * trip after another. A missing presetsMapping is tolerated; a failing layout
+ * or cellStyles request rejects, as it did when they were fetched in sequence.
+ */
+type Settled<T> =
+  | { status: "fulfilled"; value: T }
+  | { status: "rejected"; reason: unknown };
+
+// Promise.allSettled is not guaranteed on older TV engines, so settle by hand
+const settle = <T>(promise: Promise<T>): Promise<Settled<T>> =>
+  promise.then(
+    (value) => ({ status: "fulfilled", value }),
+    (reason) => ({ status: "rejected", reason })
+  );
+
+async function fetchLayoutFiles() {
+  const [layout, cellStyles, presetsMapping] = await Promise.all([
+    settle(getPromiseForType<any>("layout")),
+    settle(getPromiseForType<any>("cellStyles")),
+    settle(getPromiseForType<any>("presetsMapping")),
+  ]);
+
+  return { layout, cellStyles, presetsMapping };
+}
 
 export async function getNativeRemoteContextData(
   dispatch,
@@ -35,32 +112,32 @@ export async function getNativeRemoteContextData(
 
   loadAppContextData(dispatch, R.mergeAll([...generalConfiguration]));
 
-  try {
-    const layoutManagerPlugin = R.find(
-      R.pathSatisfies(R.is(Function), ["module", "selectLayout"])
-    )(plugins);
+  const preview = await selectActiveLayout(
+    runtimeConfigurationUrls,
+    plugins,
+    isTabletDevice
+  );
 
-    if (layoutManagerPlugin) {
-      await layoutManagerPlugin.module?.selectLayout({
-        runtimeConfigurationUrls,
-        plugin: layoutManagerPlugin,
-        isTablet: isTabletDevice,
-      });
-    } else {
-      const layoutId = await localStorage.getItem(ACTIVE_LAYOUT_ID_STORAGE_KEY);
+  let layoutFiles = await fetchLayoutFiles();
+
+  if (layoutFiles.layout.status === "rejected") {
+    if (preview !== "applied") throw layoutFiles.layout.reason;
 
-      if (layoutId) {
-        await AppLoaderBridge?.switchLayout(layoutId, null);
-      }
-    }
-  } catch (error) {
     logger.error({
-      message: "Error selecting layout using layout manager plugin",
-      data: error,
+      message: "Persisted preview layout failed to load",
+      data: layoutFiles.layout.reason,
     });
+
+    // The files fetched so far belong to the broken preview layout
+    await restoreInvalidPreview();
+    layoutFiles = await fetchLayoutFiles();
+  }
+
+  if (layoutFiles.layout.status === "rejected") {
+    throw layoutFiles.layout.reason;
   }
 
-  const layout = await getPromiseForType("layout");
+  const layout = layoutFiles.layout.value;
 
   const layoutLoadingErrorMessage = "Failed to load layout data";
 
@@ -78,16 +155,17 @@ export async function getNativeRemoteContextData(
 
   dispatch(AppData.actions.merge({ layoutVersion: apiVersion || "v1" }));
 
-  const resolvedPromises = await mapPromises(getPromiseForType, ["cellStyles"]);
+  if (layoutFiles.cellStyles.status === "rejected") {
+    throw layoutFiles.cellStyles.reason;
+  }
 
-  let optionalResolvedPromise;
+  const resolvedPromises = [layoutFiles.cellStyles.value];
 
-  try {
-    optionalResolvedPromise = await getPromiseForType("presetsMapping");
-  } catch (e) {
-    // don't break loading sequence if presetsMapping does not exist
-    // only general error could be intercepted here so no way divide flow
-  }
+  // don't break loading sequence if presetsMapping does not exist
+  const optionalResolvedPromise =
+    layoutFiles.presetsMapping.status === "fulfilled"
+      ? layoutFiles.presetsMapping.value
+      : undefined;
 
   const remoteData = R.mergeAll([
     ...resolvedPromises,

package/App/remoteContextReloader/helpers.ts

@@ -119,8 +119,9 @@ export async function getPromiseForType<T = FileResponse>(
   try {
     const response = await AppLoaderBridge?.getFile(key, null);
 
+    // Native bridges resolve a JSON string; the web bridge resolves the parsed file.
     return {
-      [key]: JSON.parse(response),
+      [key]: typeof response === "string" ? JSON.parse(response) : response,
     } as T;
   } catch (e) {
     throw new Error("cannot retrieve configuration data for " + key);

package/App/uiActions/index.ts

@@ -0,0 +1,13 @@
+import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
+
+import { registerMuteUnmuteUIAction } from "./muteUnmute";
+
+/**
+ * App-wide UI actions owned by QuickBrick, registered once at startup.
+ * Actions scoped to a live object (e.g. player speed) register with their owner.
+ */
+export const registerCoreUIActions = (): (() => void) => {
+  const unregisters = isTV() ? [] : [registerMuteUnmuteUIAction()];
+
+  return () => unregisters.forEach((unregister) => unregister());
+};