@applicaster/quick-brick-core 16.0.0-rc.126 → 16.0.0-rc.128

package/App/ActionSetters/index.ts

@@ -4,8 +4,8 @@ import { allSettled } from "promise";
 import { useActions } from "@applicaster/zapp-react-native-utils/reactHooks/actions";
 
 import * as React from "react";
-import { coreAppLogger } from "../logger";
-const logger = coreAppLogger.addSubsystem("AppLifeCycleManager");
+import { subsystemLogger } from "@applicaster/zapp-react-native-utils/logger";
+const logger = subsystemLogger("app/lifecycle", "AppLifeCycleManager");
 
 const debugActions = (actions) =>
   logger.debug({

package/App/ActionsProvider/ActionsProvider.tsx

@@ -8,7 +8,7 @@ import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
 import { LegacyActionsRegistryAdapter } from "./LegacyActionsRegistryAdapter";
 
 const { log_debug } = createLogger({
-  subsystem: "ActionsProvider",
+  subsystem: "core/actions",
   category: "ActionRegistration",
 });
 

package/App/ActionsProvider/LegacyActionsRegistryAdapter.tsx

@@ -5,7 +5,7 @@ import { uiActionsRegistry } from "@applicaster/zapp-react-native-utils/uiAction
 import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
 
 const { log_debug, log_warning } = createLogger({
-  subsystem: "LegacyActionsRegistryAdapter",
+  subsystem: "core/actions/legacy_registry",
   category: "ActionRegistration",
 });
 

package/App/AssetCache/logger.ts

@@ -5,6 +5,6 @@ import { coreAppLogger } from "../logger";
 export const { log_verbose, log_debug, log_warning, log_info, log_error } =
   createLogger({
     category: "AssetCache",
-    subsystem: "quick-brick-core",
+    subsystem: "storage/asset_cache",
     parent: coreAppLogger,
   });

package/App/DeepLinking/URLSchemeListener/URLSchemeContextProvider.tsx

@@ -3,6 +3,7 @@ import React, {
   createContext,
   useEffect,
   useCallback,
+  useMemo,
   ComponentType,
   ReactChild,
 } from "react";
@@ -196,9 +197,11 @@ function URLSchemeContextProvider(props: Props) {
     };
   }, []);
 
+  const contextValue = useMemo(() => ({ url: state, done }), [state, done]);
+
   return (
     <View style={fillStyles.container}>
-      <URLSchemeContext.Provider value={{ url: state, done }}>
+      <URLSchemeContext.Provider value={contextValue}>
         {props.children}
       </URLSchemeContext.Provider>
     </View>

package/App/DeepLinking/logger.ts

@@ -5,6 +5,6 @@ import { coreAppLogger } from "../logger";
 export const { log_verbose, log_debug, log_warning, log_info, log_error } =
   createLogger({
     category: "DeepLinking",
-    subsystem: "General",
+    subsystem: "app/deep_linking",
     parent: coreAppLogger,
   });

package/App/ErrorBoundary/index.tsx

@@ -1,13 +1,16 @@
 import * as React from "react";
 import pick from "lodash/pick";
 
-import { coreLogger } from "@applicaster/zapp-react-native-utils/logger";
+import { subsystemLogger } from "@applicaster/zapp-react-native-utils/logger";
 import { ErrorScreen } from "@applicaster/zapp-react-native-ui-components/Components/ErrorScreen";
 
 import { useErrorStore } from "./store";
 import * as QuickBrickManager from "@applicaster/zapp-react-native-bridge/QuickBrick";
 
-const errorBoundaryLogger = coreLogger.addSubsystem("react_error-boundary");
+const errorBoundaryLogger = subsystemLogger(
+  "crash/error_boundary",
+  "ErrorBoundary"
+);
 
 type Props = {
   children: React.ReactNode;

package/App/NavigationProvider/NavigationProvider.tsx

@@ -45,7 +45,6 @@ import {
   startUpHookPluginIdentifiersSelector,
 } from "./navigator/selectors";
 
-import { coreAppLogger } from "../logger";
 import {
   getPlatform,
   isTV,
@@ -89,8 +88,9 @@ import {
   useLayoutVersion,
   useRivers,
 } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { subsystemLogger } from "@applicaster/zapp-react-native-utils/logger";
 
-const logger = coreAppLogger.addSubsystem("Navigator");
+const logger = subsystemLogger("ui/navigation", "Navigator");
 
 type Props = {
   children?: React.ReactChild;

package/App/NavigationProvider/utils.ts

@@ -7,16 +7,16 @@ import {
 } from "@applicaster/zapp-react-native-utils/navigationUtils";
 import { findPluginByType } from "@applicaster/zapp-react-native-utils/pluginUtils";
 
-import { coreAppLogger } from "../logger";
 import { isString } from "@applicaster/zapp-react-native-utils/stringUtils";
 import { SCREEN_TYPES } from "@applicaster/zapp-react-native-utils/navigationUtils/itemTypes";
 import { isNilOrEmpty } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+import { subsystemLogger } from "@applicaster/zapp-react-native-utils/logger";
 
 const EXTERNAL_URL_TYPE = "external_url";
 const EXTERNAL_URL_FLAG = "open_external_url";
 const WEBVIEW_SCREEN_IDENTIFIER = "webview_screen_qb";
 
-const logger = coreAppLogger.addSubsystem("Navigator");
+const logger = subsystemLogger("ui/navigation", "Navigator");
 
 /**
  * Drops a leading `/hooks/<screen_id>` segment from a path.

package/App/NetworkStatusProvider/NetworkStatusProvider.tsx

@@ -12,11 +12,12 @@ import {
   unsubscribeToDeviceNetworkChanges,
 } from "./utils";
 import { usePrevious } from "@applicaster/zapp-react-native-utils/reactHooks/utils";
-import { coreAppLogger } from "../logger";
+
 import { useResumeVerifiedNetInfo } from "./useResumeVerifiedNetInfo";
 import { describeNetInfo } from "./resumeVerification";
+import { subsystemLogger } from "@applicaster/zapp-react-native-utils/logger";
 
-const logger = coreAppLogger.addSubsystem("NetworkStatusProvider");
+const logger = subsystemLogger("network/reachability", "NetworkStatusProvider");
 
 // Use default netInfo config for all platforms (important for web platform which otherwise
 // will use backend root which is not responding for HEAD request)
@@ -54,10 +55,17 @@ export const NetworkStatusProvider = ({
   const { netInfo: verifiedNetInfo, stillOfflineAfterResumeCount } =
     useResumeVerifiedNetInfo(liveNetInfo);
 
-  const combinedNetInfo: NetInfoState & {
-    deviceStatus?: NetStatus;
-    stillOfflineAfterResumeCount: number;
-  } = { ...verifiedNetInfo, stillOfflineAfterResumeCount };
+  // Memoized so consumers only re-render when the published status changes,
+  // not on every render of this provider
+  const combinedNetInfo = React.useMemo<
+    NetInfoState & {
+      deviceStatus?: NetStatus;
+      stillOfflineAfterResumeCount: number;
+    }
+  >(
+    () => ({ ...verifiedNetInfo, stillOfflineAfterResumeCount }),
+    [verifiedNetInfo, stillOfflineAfterResumeCount]
+  );
 
   const { onConnectionTypeChanged, onConnectionLost, onConnectionRestored } =
     React.useMemo<NetworkHooks>(() => getNetworkHooks(plugins), []);

package/App/NetworkStatusProvider/ResumeVerificationController.ts

@@ -1,7 +1,6 @@
 import { AppState, AppStateStatus } from "react-native";
 import { NetInfoState } from "@react-native-community/netinfo";
 
-import { coreAppLogger } from "../logger";
 import { isOnline } from "./utils";
 import {
   RESUME_VERIFICATION_DELAY_MS,
@@ -10,8 +9,9 @@ import {
   isBackgroundAppState,
   isResumeVerificationEnabled,
 } from "./resumeVerification";
+import { subsystemLogger } from "@applicaster/zapp-react-native-utils/logger";
 
-const logger = coreAppLogger.addSubsystem("NetworkStatusProvider");
+const logger = subsystemLogger("network/reachability", "NetworkStatusProvider");
 
 export type ConnectionInfo = NetInfoState & { deviceStatus?: NetStatus };
 

package/App/NetworkStatusProvider/__tests__/NetworkStatusProvider.test.tsx

@@ -16,18 +16,33 @@ const mockLogger = {
   error: jest.fn(),
 };
 
-// addSubsystem runs at module load, before mockLogger is initialised: delegate lazily
-jest.mock("../../logger", () => ({
-  coreAppLogger: {
-    addSubsystem: () => ({
-      warning: (event) => mockLogger.warning(event),
-      debug: (event) => mockLogger.debug(event),
-      info: (event) => mockLogger.info(event),
-      log: (event) => mockLogger.log(event),
-      error: (event) => mockLogger.error(event),
-    }),
-  },
-}));
+// subsystemLogger runs at module load, before mockLogger is initialised: delegate lazily
+jest.mock("@applicaster/zapp-react-native-utils/logger", () => {
+  const actual = jest.requireActual(
+    "@applicaster/zapp-react-native-utils/logger"
+  );
+
+  return {
+    ...actual,
+    // Only the logger of this subsystem is replaced; every other module keeps its real one.
+    subsystemLogger: (subsystem: string) => {
+      if (subsystem !== "network/reachability") {
+        return actual.subsystemLogger(subsystem);
+      }
+
+      const logger = {
+        warning: (event) => mockLogger.warning(event),
+        debug: (event) => mockLogger.debug(event),
+        info: (event) => mockLogger.info(event),
+        log: (event) => mockLogger.log(event),
+        error: (event) => mockLogger.error(event),
+        addSubsystem: () => logger,
+      };
+
+      return logger;
+    },
+  };
+});
 
 jest.mock("react-native/Libraries/AppState/AppState", () => {
   const { EventEmitter } = require("events");

package/App/NetworkStatusProvider/__tests__/ResumeVerificationController.test.ts

@@ -12,18 +12,33 @@ const mockLogger = {
   error: jest.fn(),
 };
 
-// addSubsystem runs at module load, before mockLogger is initialised: delegate lazily
-jest.mock("../../logger", () => ({
-  coreAppLogger: {
-    addSubsystem: () => ({
-      warning: (event) => mockLogger.warning(event),
-      debug: (event) => mockLogger.debug(event),
-      info: (event) => mockLogger.info(event),
-      log: (event) => mockLogger.log(event),
-      error: (event) => mockLogger.error(event),
-    }),
-  },
-}));
+// subsystemLogger runs at module load, before mockLogger is initialised: delegate lazily
+jest.mock("@applicaster/zapp-react-native-utils/logger", () => {
+  const actual = jest.requireActual(
+    "@applicaster/zapp-react-native-utils/logger"
+  );
+
+  return {
+    ...actual,
+    // Only the logger of this subsystem is replaced; every other module keeps its real one.
+    subsystemLogger: (subsystem: string) => {
+      if (subsystem !== "network/reachability") {
+        return actual.subsystemLogger(subsystem);
+      }
+
+      const logger = {
+        warning: (event) => mockLogger.warning(event),
+        debug: (event) => mockLogger.debug(event),
+        info: (event) => mockLogger.info(event),
+        log: (event) => mockLogger.log(event),
+        error: (event) => mockLogger.error(event),
+        addSubsystem: () => logger,
+      };
+
+      return logger;
+    },
+  };
+});
 
 jest.mock("react-native/Libraries/AppState/AppState", () => {
   const { EventEmitter } = require("events");

package/App/NetworkStatusProvider/__tests__/useResumeVerifiedNetInfo.test.ts

@@ -14,18 +14,33 @@ const mockLogger = {
   error: jest.fn(),
 };
 
-// addSubsystem runs at module load, before mockLogger is initialised: delegate lazily
-jest.mock("../../logger", () => ({
-  coreAppLogger: {
-    addSubsystem: () => ({
-      warning: (event) => mockLogger.warning(event),
-      debug: (event) => mockLogger.debug(event),
-      info: (event) => mockLogger.info(event),
-      log: (event) => mockLogger.log(event),
-      error: (event) => mockLogger.error(event),
-    }),
-  },
-}));
+// subsystemLogger runs at module load, before mockLogger is initialised: delegate lazily
+jest.mock("@applicaster/zapp-react-native-utils/logger", () => {
+  const actual = jest.requireActual(
+    "@applicaster/zapp-react-native-utils/logger"
+  );
+
+  return {
+    ...actual,
+    // Only the logger of this subsystem is replaced; every other module keeps its real one.
+    subsystemLogger: (subsystem: string) => {
+      if (subsystem !== "network/reachability") {
+        return actual.subsystemLogger(subsystem);
+      }
+
+      const logger = {
+        warning: (event) => mockLogger.warning(event),
+        debug: (event) => mockLogger.debug(event),
+        info: (event) => mockLogger.info(event),
+        log: (event) => mockLogger.log(event),
+        error: (event) => mockLogger.error(event),
+        addSubsystem: () => logger,
+      };
+
+      return logger;
+    },
+  };
+});
 
 jest.mock("react-native/Libraries/AppState/AppState", () => {
   const { EventEmitter } = require("events");

package/App/ThemeManager/index.tsx

@@ -100,7 +100,12 @@ const MemoizedThemeContextProvider = React.memo(
 function ThemeManagerComponent({ children, plugins }: Props) {
   const isTablet = useIsTablet();
 
-  const themes = selectThemes(isTablet, plugins);
+  // Stable reference keeps MemoizedThemeContextProvider's byReference check
+  // effective, so theme consumers don't re-render on every parent render
+  const themes = React.useMemo(
+    () => selectThemes(isTablet, plugins),
+    [isTablet, plugins]
+  );
 
   const [selectedThemeId, setSelectedThemeId] =
     React.useState(DEFAULT_THEME_ID);

package/App/appLifeCycleManager/index.tsx

@@ -12,13 +12,13 @@ import { isAndroidPlatform } from "@applicaster/zapp-react-native-utils/reactUti
 import { networkStatusReady } from "../NetworkStatusProvider/networkStatusReady";
 import { updateSessionNumber } from "../SessionCounter/sessionCounter";
 
-import { coreAppLogger } from "../logger";
 import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
 import { isEmptyOrNil } from "@applicaster/zapp-react-native-utils/cellUtils";
 import { requiredSessionKeys } from "../../const";
 import { initializeActionSetters, useActionSetters } from "../ActionSetters";
+import { subsystemLogger } from "@applicaster/zapp-react-native-utils/logger";
 
-const logger = coreAppLogger.addSubsystem("AppLifeCycleManager");
+const logger = subsystemLogger("app/lifecycle", "AppLifeCycleManager");
 
 const isAndroid = isAndroidPlatform();
 

package/App/appRemoteDataLoader/index.tsx

@@ -2,11 +2,11 @@ import * as React from "react";
 
 import { getRemoteContextData } from "../remoteContextReloader/getRemoteContextData";
 
-import { coreAppLogger } from "../logger";
 import { UnknownAction, Dispatch } from "@reduxjs/toolkit";
 import { isAndroidPlatform } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { subsystemLogger } from "@applicaster/zapp-react-native-utils/logger";
 
-const logger = coreAppLogger.addSubsystem("AppRemoteDataLoader");
+const logger = subsystemLogger("app/loading", "AppRemoteDataLoader");
 
 /**
  * adds a call to the QuickBrickManager to tell the app is ready, reloads remote

package/App/appRemoteDataLoader/remoteDataLoader.ts

@@ -5,8 +5,8 @@ import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
 import { coreAppLogger } from "../logger";
 
 const logger = createLogger({
-  category: "PlayerController",
-  subsystem: "RemoteDataLoader",
+  category: "RemoteDataLoader",
+  subsystem: "app/loading",
   parent: coreAppLogger,
 });
 

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";
@@ -65,6 +65,33 @@ async function selectActiveLayout(
   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,
   runtimeConfigurationUrls,
@@ -91,22 +118,27 @@ export async function getNativeRemoteContextData(
     isTabletDevice
   );
 
-  let layout;
+  let layoutFiles = await fetchLayoutFiles();
 
-  try {
-    layout = await getPromiseForType("layout");
-  } catch (error) {
-    if (preview !== "applied") throw error;
+  if (layoutFiles.layout.status === "rejected") {
+    if (preview !== "applied") throw layoutFiles.layout.reason;
 
     logger.error({
       message: "Persisted preview layout failed to load",
-      data: error,
+      data: layoutFiles.layout.reason,
     });
 
+    // The files fetched so far belong to the broken preview layout
     await restoreInvalidPreview();
-    layout = await getPromiseForType("layout");
+    layoutFiles = await fetchLayoutFiles();
+  }
+
+  if (layoutFiles.layout.status === "rejected") {
+    throw layoutFiles.layout.reason;
   }
 
+  const layout = layoutFiles.layout.value;
+
   const layoutLoadingErrorMessage = "Failed to load layout data";
 
   if (isEmpty(layout)) {
@@ -123,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/quick-brick-core",
-  "version": "16.0.0-rc.126",
+  "version": "16.0.0-rc.128",
   "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-rc.126",
-    "@applicaster/quick-brick-core-plugins": "16.0.0-rc.126",
-    "@applicaster/zapp-pipes-v2-client": "16.0.0-rc.126",
-    "@applicaster/zapp-react-native-bridge": "16.0.0-rc.126",
-    "@applicaster/zapp-react-native-redux": "16.0.0-rc.126",
-    "@applicaster/zapp-react-native-ui-components": "16.0.0-rc.126",
-    "@applicaster/zapp-react-native-utils": "16.0.0-rc.126",
+    "@applicaster/applicaster-types": "16.0.0-rc.128",
+    "@applicaster/quick-brick-core-plugins": "16.0.0-rc.128",
+    "@applicaster/zapp-pipes-v2-client": "16.0.0-rc.128",
+    "@applicaster/zapp-react-native-bridge": "16.0.0-rc.128",
+    "@applicaster/zapp-react-native-redux": "16.0.0-rc.128",
+    "@applicaster/zapp-react-native-ui-components": "16.0.0-rc.128",
+    "@applicaster/zapp-react-native-utils": "16.0.0-rc.128",
     "atob": "^2.1.2",
     "axios": "^0.28.0",
     "btoa": "^1.2.1",