@applicaster/quick-brick-core 15.1.4-rc.0 → 15.1.5-alpha.7597480209

package/App/ActionSetters/index.ts

@@ -20,10 +20,6 @@ const warnUndefinedContext = (context) =>
     data: { context },
   });
 
-type Subscription = {
-  [x: string]: () => any;
-};
-
 const getModuleContext = R.path(["module", "context"]);
 
 const getContexts = R.compose(
@@ -63,24 +59,40 @@ const useSubscribeToActionProviders = () => {
 export const useRiverInitialState = () => {
   const key = "getRiverInitialState";
   const actionProvidersSubscriptions = useSubscribeToActionProviders();
+  // Capture river-init promises once. Re-calling getRiverInitialState() on every
+  // context re-render causes thrash and can drop already-completed observables.
+  // Plugins should return Promise.resolve() when already initialized (not undefined).
+  const capturedPromisesRef = React.useRef<Promise<unknown>[] | null>(null);
+
+  if (
+    capturedPromisesRef.current === null &&
+    actionProvidersSubscriptions.length > 0
+  ) {
+    const providersWithMethod = actionProvidersSubscriptions.filter(
+      (item) => item?.[key]
+    );
+
+    const promises = providersWithMethod
+      .map((item) => item[key]())
+      .filter(Boolean) as Promise<unknown>[];
+
+    // Lock when every river-init provider returned a promise, or none expose it.
+    // Retry while a provider still returns undefined (getInitialState not started).
+    if (
+      providersWithMethod.length === 0 ||
+      promises.length === providersWithMethod.length
+    ) {
+      capturedPromisesRef.current = promises;
+    }
+  }
 
-  const subscriptions = React.useMemo(() => {
-    if (!actionProvidersSubscriptions.length) return undefined;
-
-    return actionProvidersSubscriptions.reduce((acc, item) => {
-      const riverInitialStatePromise = item[key]?.();
-
-      if (riverInitialStatePromise) {
-        acc.push(riverInitialStatePromise);
-      }
-
-      return acc;
-    }, [] as Subscription[]);
-  }, [actionProvidersSubscriptions]);
+  if (!actionProvidersSubscriptions.length) {
+    return undefined;
+  }
 
-  if (!actionProvidersSubscriptions.length) return undefined;
-
-  return subscriptions;
+  return capturedPromisesRef.current === null
+    ? undefined
+    : capturedPromisesRef.current;
 };
 
 const getActionInitialStateSetters = (key) => {

package/App/ModalProvider/ModalBottomSheet/DraggableBottomSheet/__tests__/index.test.tsx

@@ -0,0 +1,88 @@
+import React from "react";
+import { View } from "react-native";
+import { render } from "@testing-library/react-native";
+import { State } from "react-native-gesture-handler";
+import { DraggableBottomSheet } from "../index";
+
+// Render the gesture handlers as passthrough Views so we can mount the sheet
+// and drive its release handler directly. State stays real (we need ACTIVE).
+jest.mock("react-native-gesture-handler", () => {
+  const RN = require("react-native");
+  const ReactActual = require("react");
+  const actual = jest.requireActual("react-native-gesture-handler");
+
+  const Passthrough = ReactActual.forwardRef(({ children }: any, _ref: any) => (
+    <RN.View>{children}</RN.View>
+  ));
+
+  return {
+    __esModule: true,
+    ...actual,
+    PanGestureHandler: Passthrough,
+    TapGestureHandler: Passthrough,
+  };
+});
+
+// height 800, sheetHeight 400, no header:
+//   SnapPoints.top = 800 - 400 = 400 (lastSnap after mount)
+//   SnapPoints.threshold = max(800 - 400 / 2, 100) = 600
+// Release dismisses when lastSnap + translationY + 0.05 * velocityY > 600,
+// i.e. once the drag+toss pushes past 200px.
+const mountSheet = () => {
+  const dismiss = jest.fn();
+  const ref = React.createRef<DraggableBottomSheet>();
+
+  render(
+    <DraggableBottomSheet
+      ref={ref}
+      header={() => null}
+      dismiss={dismiss}
+      visible={true}
+      sheetHeight={400}
+      width={320}
+      height={800}
+      hasHeader={false}
+      maxWidth={320}
+    >
+      <View testID="child" />
+    </DraggableBottomSheet>
+  );
+
+  return { instance: ref.current as DraggableBottomSheet, dismiss };
+};
+
+const release = (
+  instance: DraggableBottomSheet,
+  translationY: number,
+  velocityY = 0
+) =>
+  instance._onHandlerStateChange({
+    nativeEvent: { oldState: State.ACTIVE, translationY, velocityY },
+  });
+
+describe("DraggableBottomSheet release", () => {
+  // Mounting an open sheet schedules a deferred animateIn via setTimeout. Keep
+  // it on fake timers so it never fires into a torn-down Jest environment.
+  beforeEach(() => jest.useFakeTimers());
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  it("dismisses when the release lands past the threshold", () => {
+    const { instance, dismiss } = mountSheet();
+
+    release(instance, 300);
+
+    expect(dismiss).toHaveBeenCalledTimes(1);
+  });
+
+  it("springs back (does not dismiss) when the release is below the threshold", () => {
+    const { instance, dismiss } = mountSheet();
+
+    release(instance, 50);
+
+    expect(dismiss).not.toHaveBeenCalled();
+  });
+});

package/App/ModalProvider/ModalBottomSheet/DraggableBottomSheet/index.tsx

@@ -1,15 +1,24 @@
-import React, { Component, ReactChild, ReactElement } from "react";
+import React, { Component, ReactElement } from "react";
 import { Animated, StyleSheet, View, Easing } from "react-native";
 import {
   PanGestureHandler,
-  NativeViewGestureHandler,
   State,
   TapGestureHandler,
 } from "react-native-gesture-handler";
 
 import { SnapPoints } from "./SnapPoints";
-
-const USE_NATIVE_DRIVER = true;
+import {
+  BottomSheetContext,
+  BottomSheetContextValue,
+} from "@applicaster/zapp-react-native-utils/bottomSheet";
+
+// Must stay false: the sheet drives _dragY from old-API PanGestureHandler
+// onGestureEvent props via RN Animated.event. This RNGH version cannot attach
+// a native (useNativeDriver: true) Animated.event to those handlers — it leaks
+// the AnimatedEvent object into the JS event path and throws "Expected
+// onGestureHandlerEvent listener to be a function". Native-threaded dragging
+// needs the full reanimated + Gesture-API migration (tracked separately).
+const USE_NATIVE_DRIVER = false;
 const HEADER_HEIGHT = 44;
 
 const ANIMATION_DURATION = 400;
@@ -24,7 +33,7 @@ const styles = StyleSheet.create({
 });
 
 type Props = {
-  children: ReactChild;
+  children: ReactElement;
   header: (boolean) => ReactElement;
   dismiss: () => void;
   visible: boolean;
@@ -49,35 +58,24 @@ export class DraggableBottomSheet extends Component<Props, ComponentState> {
   _isMounted = false;
   _animatedIn = false;
   _animating = false;
-  _lastScrollYValue: number;
-  _lastScrollY: Animated.Value;
   _dragY: Animated.Value;
-  _reverseLastScrollY: Animated.AnimatedInterpolation<number>;
   _translateYOffset: Animated.Value;
   _translateY: Animated.AnimatedInterpolation<number>;
   _snapPoints: SnapPoints;
   _prevContentHeight = 0;
+  _bottomSheetContextValue: BottomSheetContextValue;
 
   _callWhenMounted: () => void | null;
 
-  _onRegisterLastScroll: (...args: any[]) => void;
+  // One shared JS Animated.event feeds _dragY for every drag handler (top
+  // handle, header drag-area, body). Safe because useNativeDriver is false — the
+  // event is a plain JS listener that setValue's _dragY for whichever handler
+  // is active, and only one gesture is ever active at a time.
   _onGestureEvent: (...args: any[]) => void;
 
   constructor(props) {
     super(props);
 
-    this._lastScrollYValue = 0;
-    this._lastScrollY = new Animated.Value(0);
-
-    this._onRegisterLastScroll = Animated.event(
-      [{ nativeEvent: { contentOffset: { y: this._lastScrollY } } }],
-      { useNativeDriver: USE_NATIVE_DRIVER }
-    );
-
-    this._lastScrollY.addListener(({ value }) => {
-      this._lastScrollYValue = value;
-    });
-
     this._dragY = new Animated.Value(0);
 
     this._onGestureEvent = Animated.event(
@@ -85,10 +83,11 @@ export class DraggableBottomSheet extends Component<Props, ComponentState> {
       { useNativeDriver: USE_NATIVE_DRIVER }
     );
 
-    this._reverseLastScrollY = Animated.multiply(
-      new Animated.Value(-1),
-      this._lastScrollY
-    );
+    this._bottomSheetContextValue = {
+      masterDrawerRef: this.masterdrawer,
+      onDragGestureEvent: this._onGestureEvent,
+      onDragStateChange: this._onHeaderHandlerStateChange,
+    };
 
     const initialSnapPoints = new SnapPoints(props.height, props.sheetHeight);
 
@@ -181,7 +180,7 @@ export class DraggableBottomSheet extends Component<Props, ComponentState> {
 
     this._translateY = Animated.add(
       this._translateYOffset,
-      Animated.add(this._dragY, this._reverseLastScrollY)
+      this._dragY
     ).interpolate({
       inputRange: [this._snapPoints.top, this._snapPoints.bottom],
       outputRange: [this._snapPoints.top, this._snapPoints.bottom],
@@ -226,10 +225,6 @@ export class DraggableBottomSheet extends Component<Props, ComponentState> {
       return;
     }
 
-    if (nativeEvent.oldState === State.BEGAN) {
-      this._lastScrollY.setValue(0);
-    }
-
     this._onHandlerStateChange({ nativeEvent });
   };
 
@@ -240,8 +235,7 @@ export class DraggableBottomSheet extends Component<Props, ComponentState> {
 
     if (nativeEvent.oldState === State.ACTIVE) {
       const { velocityY } = nativeEvent;
-      let { translationY } = nativeEvent;
-      translationY -= this._lastScrollYValue;
+      const { translationY } = nativeEvent;
       const dragToss = 0.05;
 
       const endOffsetY =
@@ -300,7 +294,7 @@ export class DraggableBottomSheet extends Component<Props, ComponentState> {
           >
             <PanGestureHandler
               ref={this.drawerheader}
-              simultaneousHandlers={[this.scroll, this.masterdrawer]}
+              simultaneousHandlers={[this.masterdrawer]}
               shouldCancelWhenOutside={false}
               onGestureEvent={this._onGestureEvent}
               onHandlerStateChange={this._onHeaderHandlerStateChange}
@@ -309,31 +303,11 @@ export class DraggableBottomSheet extends Component<Props, ComponentState> {
                 {this.props?.header(this.state.dragging)}
               </Animated.View>
             </PanGestureHandler>
-            <PanGestureHandler
-              ref={this.drawer}
-              simultaneousHandlers={[this.scroll, this.masterdrawer]}
-              shouldCancelWhenOutside={false}
-              onGestureEvent={this._onGestureEvent}
-              onHandlerStateChange={this._onHandlerStateChange}
-            >
+            <BottomSheetContext.Provider value={this._bottomSheetContextValue}>
               <Animated.View style={styles.container}>
-                <NativeViewGestureHandler
-                  ref={this.scroll}
-                  waitFor={this.masterdrawer}
-                  simultaneousHandlers={this.drawer}
-                >
-                  <Animated.ScrollView
-                    bounces={false}
-                    onScrollBeginDrag={this._onRegisterLastScroll}
-                    scrollEventThrottle={1}
-                    scrollEnabled={false}
-                    showsVerticalScrollIndicator={false}
-                  >
-                    {this.props.children}
-                  </Animated.ScrollView>
-                </NativeViewGestureHandler>
+                {this.props.children}
               </Animated.View>
-            </PanGestureHandler>
+            </BottomSheetContext.Provider>
           </Animated.View>
         </View>
       </TapGestureHandler>

package/App/remoteContextReloader/cachedRemoteJson.ts

@@ -0,0 +1,37 @@
+/**
+ * Boot-time dedupe for remote JSON GETs.
+ * Shared across packages via globalThis so layout-manager + core
+ * don't double-fetch the same URL during startup.
+ */
+declare global {
+  // eslint-disable-next-line no-var
+  var __QB_REMOTE_JSON_INFLIGHT__: Map<string, Promise<unknown>> | undefined;
+}
+
+export function cachedRemoteJson<T>(
+  url: string,
+  fetcher: () => Promise<T>
+): Promise<T> {
+  if (!url) {
+    return fetcher();
+  }
+
+  if (!globalThis.__QB_REMOTE_JSON_INFLIGHT__) {
+    globalThis.__QB_REMOTE_JSON_INFLIGHT__ = new Map();
+  }
+
+  const cache = globalThis.__QB_REMOTE_JSON_INFLIGHT__;
+
+  if (!cache.has(url)) {
+    cache.set(
+      url,
+      fetcher().catch((error) => {
+        cache.delete(url);
+
+        throw error;
+      })
+    );
+  }
+
+  return cache.get(url) as Promise<T>;
+}

package/App/remoteContextReloader/getRemoteContextData/getLegacyRemoteContextData.ts

@@ -1,15 +1,14 @@
 import * as R from "ramda";
 import { loadAppContextData } from "@applicaster/zapp-react-native-redux";
 
-import { URL_KEYS } from "../consts";
 import {
   fetchPluginConfiguration,
-  getPromiseForKey,
-  prepareRuntimeConfigurationUrls,
+  fetchAllRemoteConfigurations,
 } from "../helpers";
 import { isTablet } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { Dimensions } from "react-native";
 import { cacheAssets } from "../../AssetCache";
+import { logger } from "@applicaster/zapp-react-native-utils/logger";
 
 const buildContextData = (remoteData) => {
   const { width, height } = Dimensions.get("window");
@@ -33,6 +32,18 @@ export async function getLegacyRemoteContextData(
   runtimeConfigurationUrls,
   plugins
 ) {
+  const t0 = performance.now();
+
+  const mark = (label: string) => {
+    logger.log({
+      message: `[PERF][remote] ${label} +${Math.round(
+        performance.now() - t0
+      )}ms`,
+    });
+  };
+
+  mark("start");
+
   const layoutManagerPlugin = R.find(
     R.pathSatisfies(R.is(Function), ["module", "selectLayout"])
   )(plugins);
@@ -50,25 +61,16 @@ export async function getLegacyRemoteContextData(
     isTablet: isTabletDevice,
   });
 
-  const { preparedRuntimeConfigurationUrls, layoutData = [] } =
-    await prepareRuntimeConfigurationUrls(
-      configurationUrls || runtimeConfigurationUrls,
-      isTabletDevice
-    );
+  mark("selectLayout done");
 
-  const promises = R.compose(
-    R.map(getPromiseForKey(preparedRuntimeConfigurationUrls)),
-    R.reject(R.isNil),
-    R.keys,
-    R.pick(URL_KEYS)
-  )(preparedRuntimeConfigurationUrls);
+  const remoteDataRaw = await fetchAllRemoteConfigurations(
+    configurationUrls || runtimeConfigurationUrls,
+    isTabletDevice
+  );
 
-  const resolvedPromises = await Promise.all(promises);
+  mark("fetchAllRemoteConfigurations done");
 
-  const remoteData = R.compose(
-    buildContextData,
-    R.mergeAll
-  )([...layoutData, ...resolvedPromises]);
+  const remoteData = buildContextData(remoteDataRaw);
 
   const useTabletLayout =
     isTabletDevice &&
@@ -83,6 +85,8 @@ export async function getLegacyRemoteContextData(
       : remoteData.cellStyles,
   });
 
+  mark("cacheAssets done");
+
   const { pluginConfigurations } = cachedRemoteData;
 
   const updatedPlugins = R.map(
@@ -105,4 +109,6 @@ export async function getLegacyRemoteContextData(
     ...appProperties,
     plugins: updatedPlugins,
   });
+
+  mark("loadAppContextData done");
 }

package/App/remoteContextReloader/getRemoteContextData/getNativeRemoteContextData.ts

@@ -20,6 +20,18 @@ export async function getNativeRemoteContextData(
   runtimeConfigurationUrls,
   plugins
 ) {
+  const t0 = performance.now();
+
+  const mark = (label: string) => {
+    logger.log({
+      message: `[PERF][remote-native] ${label} +${Math.round(
+        performance.now() - t0
+      )}ms`,
+    });
+  };
+
+  mark("start");
+
   const { width, height } = Dimensions.get("window");
 
   const isTabletDevice = isTablet(
@@ -33,6 +45,8 @@ export async function getNativeRemoteContextData(
     "pipesEndpoints",
   ]);
 
+  mark("generalConfiguration done");
+
   loadAppContextData(dispatch, R.mergeAll([...generalConfiguration]));
 
   try {
@@ -60,7 +74,10 @@ export async function getNativeRemoteContextData(
     });
   }
 
+  mark("selectLayout done");
+
   const layout = await getPromiseForType("layout");
+  mark("layout done");
 
   const layoutLoadingErrorMessage = "Failed to load layout data";
 
@@ -79,6 +96,7 @@ export async function getNativeRemoteContextData(
   dispatch(AppData.actions.merge({ layoutVersion: apiVersion || "v1" }));
 
   const resolvedPromises = await mapPromises(getPromiseForType, ["cellStyles"]);
+  mark("cellStyles done");
 
   let optionalResolvedPromise;
 
@@ -102,6 +120,8 @@ export async function getNativeRemoteContextData(
     cellStyles: remoteData.cellStyles,
   });
 
+  mark("cacheAssets done");
+
   const { pluginConfigurations } = cachedRemoteData;
 
   const updatedPlugins = R.map(
@@ -126,4 +146,6 @@ export async function getNativeRemoteContextData(
     ...appProperties,
     plugins: updatedPlugins,
   });
+
+  mark("loadAppContextData done");
 }

package/App/remoteContextReloader/helpers.ts

@@ -2,8 +2,9 @@ import axios from "axios";
 import camelize from "camelize";
 import * as R from "ramda";
 import { NativeModules } from "react-native";
-import { URL_KEY_SUFFIX } from "./consts";
+import { URL_KEY_SUFFIX, URL_KEYS } from "./consts";
 import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+import { cachedRemoteJson } from "./cachedRemoteJson";
 
 const { AppLoaderBridge } = NativeModules;
 
@@ -27,25 +28,127 @@ export const urlKeyToContext = R.compose(
   R.replace(URL_KEY_SUFFIX, "")
 );
 
-export function getPromiseForKey(runtimeConfigurationUrls) {
-  return async function (urlKey) {
-    const context = urlKeyToContext(urlKey);
-    const url = R.prop(urlKey, runtimeConfigurationUrls);
+function stripOppositePlatformUrls(runtimeConfigurationUrls, isTablet) {
+  const preparedRuntimeConfigurationUrls = { ...runtimeConfigurationUrls };
+
+  if (isTablet) {
+    if (preparedRuntimeConfigurationUrls[REMOTE_CONFIG_KEYS.TABLET.LAYOUT]) {
+      delete preparedRuntimeConfigurationUrls[REMOTE_CONFIG_KEYS.MOBILE.LAYOUT];
+    }
+
+    if (
+      preparedRuntimeConfigurationUrls[REMOTE_CONFIG_KEYS.TABLET.CELL_STYLES]
+    ) {
+      delete preparedRuntimeConfigurationUrls[
+        REMOTE_CONFIG_KEYS.MOBILE.CELL_STYLES
+      ];
+    }
+  } else {
+    delete preparedRuntimeConfigurationUrls[REMOTE_CONFIG_KEYS.TABLET.LAYOUT];
 
-    try {
+    delete preparedRuntimeConfigurationUrls[
+      REMOTE_CONFIG_KEYS.TABLET.CELL_STYLES
+    ];
+  }
+
+  return preparedRuntimeConfigurationUrls;
+}
+
+async function fetchJsonByUrlKey(runtimeConfigurationUrls, urlKey) {
+  const context = urlKeyToContext(urlKey);
+  const url = R.prop(urlKey, runtimeConfigurationUrls);
+
+  try {
+    const data = await cachedRemoteJson(url, async () => {
       const response = await axios.get(url);
 
-      const { data } = response;
+      return response.data;
+    });
 
-      return {
-        [context]: data,
-      };
-    } catch (e) {
-      throw new Error("cannot retrieve configuration data for " + urlKey);
-    }
+    return {
+      [context]: data,
+    };
+  } catch (e) {
+    throw new Error("cannot retrieve configuration data for " + urlKey);
+  }
+}
+
+export function getPromiseForKey(runtimeConfigurationUrls) {
+  return async function (urlKey) {
+    return fetchJsonByUrlKey(runtimeConfigurationUrls, urlKey);
   };
 }
 
+/**
+ * Fetches layout + remaining remote JSON in parallel.
+ * If cell_styles URL is out of sync with layout.id, refetches cells only.
+ */
+export async function fetchAllRemoteConfigurations(
+  runtimeConfigurationUrls,
+  isTablet
+) {
+  const layoutUrlKey = isTablet
+    ? REMOTE_CONFIG_KEYS.TABLET.LAYOUT
+    : REMOTE_CONFIG_KEYS.MOBILE.LAYOUT;
+
+  const cellStylesUrlKey = isTablet
+    ? REMOTE_CONFIG_KEYS.TABLET.CELL_STYLES
+    : REMOTE_CONFIG_KEYS.MOBILE.CELL_STYLES;
+
+  const layoutUrl = R.prop(layoutUrlKey, runtimeConfigurationUrls);
+  const cellStylesUrl = R.prop(cellStylesUrlKey, runtimeConfigurationUrls);
+  const layoutContext = urlKeyToContext(layoutUrlKey);
+  const cellStylesContext = urlKeyToContext(cellStylesUrlKey);
+
+  const preparedRuntimeConfigurationUrls = stripOppositePlatformUrls(
+    runtimeConfigurationUrls,
+    isTablet
+  );
+
+  const keys = R.compose(
+    R.reject(R.isNil),
+    R.keys,
+    R.pick(URL_KEYS)
+  )(preparedRuntimeConfigurationUrls);
+
+  if (!layoutUrl) {
+    const resolvedPromises = await Promise.all(
+      keys.map(getPromiseForKey(preparedRuntimeConfigurationUrls))
+    );
+
+    return R.mergeAll(resolvedPromises);
+  }
+
+  const resolvedPromises = await Promise.all(
+    keys.map(getPromiseForKey(preparedRuntimeConfigurationUrls))
+  );
+
+  const remoteData = R.mergeAll(resolvedPromises);
+  const layout = remoteData[layoutContext];
+  const layoutId = layout?.id;
+
+  if (cellStylesUrl && layoutId && !cellStylesUrl.includes(layoutId)) {
+    const splitedUrl = cellStylesUrl.split("/");
+    const oldLayoutId = splitedUrl[splitedUrl.length - 2];
+    const correctedUrl = cellStylesUrl.replace(oldLayoutId, layoutId);
+
+    await sessionStorage.setItem("rivers_configuration_id", layoutId);
+
+    const cellStyles = await cachedRemoteJson(correctedUrl, async () => {
+      const response = await axios.get(correctedUrl);
+
+      return response.data;
+    });
+
+    return {
+      ...remoteData,
+      [cellStylesContext]: cellStyles,
+    };
+  }
+
+  return remoteData;
+}
+
 export async function prepareRuntimeConfigurationUrls(
   runtimeConfigurationUrls,
   isTablet
@@ -64,31 +167,21 @@ export async function prepareRuntimeConfigurationUrls(
   const context = urlKeyToContext(layoutUrlKey);
 
   try {
-    const response = await axios.get(layoutUrl);
-    const { data } = response;
-    const layoutData = [{ [context]: data }];
-    const { id: layoutId } = data;
+    const data = await cachedRemoteJson(layoutUrl, async () => {
+      const response = await axios.get(layoutUrl);
 
-    const preparedRuntimeConfigurationUrls = { ...runtimeConfigurationUrls };
-    delete preparedRuntimeConfigurationUrls[layoutUrlKey];
+      return response.data;
+    });
 
-    if (isTablet) {
-      preparedRuntimeConfigurationUrls[REMOTE_CONFIG_KEYS.TABLET.LAYOUT] &&
-        delete preparedRuntimeConfigurationUrls[
-          REMOTE_CONFIG_KEYS.MOBILE.LAYOUT
-        ];
+    const layoutData = [{ [context]: data }];
+    const { id: layoutId } = data;
 
-      preparedRuntimeConfigurationUrls[REMOTE_CONFIG_KEYS.TABLET.CELL_STYLES] &&
-        delete preparedRuntimeConfigurationUrls[
-          REMOTE_CONFIG_KEYS.MOBILE.CELL_STYLES
-        ];
-    } else {
-      delete preparedRuntimeConfigurationUrls[REMOTE_CONFIG_KEYS.TABLET.LAYOUT];
+    const preparedRuntimeConfigurationUrls = stripOppositePlatformUrls(
+      runtimeConfigurationUrls,
+      isTablet
+    );
 
-      delete preparedRuntimeConfigurationUrls[
-        REMOTE_CONFIG_KEYS.TABLET.CELL_STYLES
-      ];
-    }
+    delete preparedRuntimeConfigurationUrls[layoutUrlKey];
 
     if (cellStylesUrl && !cellStylesUrl.includes(layoutId)) {
       const splitedUrl = cellStylesUrl.split("/");

package/package.json

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