@lowdefy/shell 3.23.2 → 7.2.0

package/src/native/whenAppReady.js

@@ -0,0 +1,48 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+/**
+ * Waits until the open app can act for its caller: the auth has read the token and is open (not
+ * starting, not locked) and the session holds a root. Launch work (a notification button, a quick
+ * action, share-in, the queue's replay, background fetch) waits on it, so none of it runs with no
+ * token loaded or no root to read.
+ *
+ * @param {Object} params
+ * @param {Object} params.auth The app's auth (createAppAuth).
+ * @param {Object} params.session The app's session (createAppSession).
+ * @returns {{ promise: Promise<void>, stop: () => void }} stop stops waiting; the promise then never
+ *   settles.
+ */
+function whenAppReady({ auth, session }) {
+  const unsubscribes = [];
+  const stop = () => unsubscribes.splice(0).forEach((unsubscribe) => unsubscribe());
+  const promise = new Promise((resolve) => {
+    function check() {
+      if (auth.getState().status === 'open' && session.getState().root !== null) {
+        stop();
+        resolve();
+        return true;
+      }
+      return false;
+    }
+    if (!check()) {
+      unsubscribes.push(auth.subscribe(check), session.subscribe(check));
+    }
+  });
+  return { promise, stop };
+}
+
+export default whenAppReady;

package/src/navigation/SlotContext.js

@@ -0,0 +1,24 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { createContext } from 'react';
+
+// The index of the frame group (app/(t0,t1,t2,t3,t4)) a screen lives in, which its group layout
+// provides from the segment Expo Router gives it. A screen cannot read it from useSegments: those
+// are the focused route's, so every tab rendered at once would take the focused tab's index.
+const SlotContext = createContext(0);
+
+export default SlotContext;

package/src/navigation/frameSlots.js

@@ -0,0 +1,27 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// The route groups the frame's screens live in: app/(t0,t1,t2,t3,t4) is one set of routes shared
+// by five groups. With a tabs frame each tab is a group, with its own stack; mobile.menus.tabs has
+// at most five items. A drawer or stack frame uses the first group only.
+const FRAME_SLOTS = ['t0', 't1', 't2', 't3', 't4'];
+
+function getSlotIndex(segment) {
+  return FRAME_SLOTS.indexOf(String(segment).replace(/^\(|\)$/g, ''));
+}
+
+export { getSlotIndex };
+export default FRAME_SLOTS;

package/src/navigation/getFrame.js

@@ -0,0 +1,30 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// The frame an app's mobile menus declare: { kind: 'tabs', items }, { kind: 'drawer', items } or
+// { kind: 'stack' }. The server drops the items a caller may not open, so a tabs frame left with
+// fewer than two items, or a drawer with none, falls back to a stack.
+function getFrame(menus) {
+  if ((menus?.tabs?.length ?? 0) >= 2) {
+    return { kind: 'tabs', items: menus.tabs };
+  }
+  if ((menus?.drawer?.length ?? 0) >= 1) {
+    return { kind: 'drawer', items: menus.drawer };
+  }
+  return { kind: 'stack', items: [] };
+}
+
+export default getFrame;

package/src/navigation/getInitialScreenOptions.js

@@ -0,0 +1,63 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { type } from '@lowdefy/helpers';
+
+function noop() {}
+
+/**
+ * The header options a Screen page's config gives before the page renders, in the shape a Screen
+ * reports (client-native screen/Screen.js): the parts that size the bar (a large title, a search
+ * field) and how it is drawn (a backgroundTint's clear bar), from literal properties. The Screen
+ * reports its full options once it renders; these set the bar first, so the page's scroll view is
+ * first laid out under the bar it will have. iOS keeps a large title collapsed when the page's
+ * scroll view was laid out under a standard bar before the large title came.
+ *
+ * @param {Object} params
+ * @param {Object} params.pageConfig The page config, as the server sends it.
+ * @returns {Object|null} The options, or null for a page that is not a Screen.
+ */
+function getInitialScreenOptions({ pageConfig }) {
+  if (pageConfig.type !== 'Screen') {
+    return null;
+  }
+  const properties = pageConfig.properties ?? {};
+  const headerSearch = properties.headerSearch;
+  return {
+    backgroundTint: !type.isNone(properties.backgroundTint),
+    headerActions: [],
+    headerBottom: false,
+    headerLeft: undefined,
+    headerRight: undefined,
+    headerSearch: type.isObject(headerSearch)
+      ? {
+          autoFocus: false,
+          hideWhenScrolling: headerSearch.hideWhenScrolling === true,
+          onCancel: noop,
+          onChangeText: noop,
+          onSearch: noop,
+          placeholder: type.isString(headerSearch.placeholder)
+            ? headerSearch.placeholder
+            : undefined,
+        }
+      : undefined,
+    largeTitle: properties.largeTitle === true,
+    presentation: type.isString(properties.presentation) ? properties.presentation : 'card',
+    title: type.isString(properties.title) ? properties.title : undefined,
+  };
+}
+
+export default getInitialScreenOptions;

package/src/navigation/getInitialScreenOptions.test.js

@@ -0,0 +1,66 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import getInitialScreenOptions from './getInitialScreenOptions.js';
+
+test('getInitialScreenOptions reads the bar a Screen config gives before it renders', () => {
+  const options = getInitialScreenOptions({
+    pageConfig: {
+      type: 'Screen',
+      properties: {
+        title: 'My work',
+        largeTitle: true,
+        headerSearch: { placeholder: 'Search designs', hideWhenScrolling: true },
+        backgroundTint: { color: '#ff7a45' },
+      },
+    },
+  });
+  expect(options).toMatchObject({
+    backgroundTint: true,
+    headerActions: [],
+    headerBottom: false,
+    largeTitle: true,
+    presentation: 'card',
+    title: 'My work',
+  });
+  expect(options.headerSearch).toMatchObject({
+    autoFocus: false,
+    hideWhenScrolling: true,
+    placeholder: 'Search designs',
+  });
+  // The Screen sets the search handlers once it renders.
+  expect(() => options.headerSearch.onChangeText('a')).not.toThrow();
+});
+
+test('getInitialScreenOptions takes only literal properties, and leaves the rest to the Screen', () => {
+  const options = getInitialScreenOptions({
+    pageConfig: {
+      type: 'Screen',
+      properties: { title: { _state: 'task.key' }, largeTitle: { _state: 'large' } },
+    },
+  });
+  expect(options).toMatchObject({
+    backgroundTint: false,
+    headerSearch: undefined,
+    largeTitle: false,
+    title: undefined,
+  });
+  expect(getInitialScreenOptions({ pageConfig: { type: 'Screen' } }).largeTitle).toBe(false);
+});
+
+test('getInitialScreenOptions gives nothing for a page that is not a Screen', () => {
+  expect(getInitialScreenOptions({ pageConfig: { type: 'Box', properties: {} } })).toBeNull();
+});

package/src/navigation/getPresentation.js

@@ -0,0 +1,28 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// The native stack presentation for a Screen page's presentation property.
+const PRESENTATIONS = {
+  card: 'card',
+  modal: 'modal',
+  sheet: 'formSheet',
+};
+
+function getPresentation(presentation) {
+  return PRESENTATIONS[presentation] ?? 'card';
+}
+
+export default getPresentation;

package/src/navigation/getSlotRootPath.js

@@ -0,0 +1,27 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import getFrame from './getFrame.js';
+
+// The page path a frame group's first screen shows: its tab's page, or the app's home page.
+function getSlotRootPath({ root, slotIndex }) {
+  const frame = getFrame(root.menus);
+  const pageId = frame.kind === 'tabs' ? frame.items[slotIndex]?.pageId : root.homePageId;
+  const entry = root.pageIndex.find((indexEntry) => indexEntry.pageId === pageId);
+  return entry?.path ?? null;
+}
+
+export default getSlotRootPath;

package/src/navigation/getStackOptions.js

@@ -0,0 +1,185 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import React from 'react';
+import { View } from 'react-native';
+
+import getPresentation from './getPresentation.js';
+
+const SIDES = { left: 'Left', right: 'Right' };
+
+function toSfSymbol(name) {
+  return name === null ? undefined : { type: 'sfSymbol', name };
+}
+
+// A menu item as a native UIMenu action: its title, its SF Symbol, and red when destructive.
+function toNativeMenuAction(item) {
+  return {
+    type: 'action',
+    destructive: item.destructive,
+    disabled: item.disabled,
+    icon: toSfSymbol(item.symbol),
+    label: item.title,
+    onPress: item.onPress,
+  };
+}
+
+// An action as a native iOS bar button: its SF Symbol, in the bar's shared glass background. An
+// action with a menu is a bar button that opens a native menu (UIMenu) of its items, drawn with
+// its title when its icon has no SF Symbol. Any other icon with no SF Symbol draws as its Lucide
+// icon in a custom item.
+function toNativeItem(action) {
+  if (action.menu !== null) {
+    return {
+      type: 'menu',
+      accessibilityLabel: action.title,
+      disabled: action.disabled,
+      icon: toSfSymbol(action.sfSymbol),
+      identifier: action.id,
+      label: action.title,
+      menu: { items: action.menu.map(toNativeMenuAction) },
+    };
+  }
+  if (action.sfSymbol === null) {
+    return { type: 'custom', element: action.render() };
+  }
+  return {
+    type: 'button',
+    accessibilityLabel: action.title,
+    disabled: action.disabled,
+    icon: { type: 'sfSymbol', name: action.sfSymbol },
+    identifier: action.id,
+    label: action.title,
+    onPress: action.onPress,
+  };
+}
+
+// One side of the header (left or right): the Screen's slot blocks, then its actions on that
+// side. On iOS, a side with actions is a list of native bar items (the slot as a custom item); a
+// side with only the slot is its custom view. Elsewhere, a side is a row of the slot and the
+// actions as icon buttons. A side with neither is left out, so a drawer's menu button stays.
+function getSideOptions({ actions, platform, side, slot }) {
+  const sideActions = actions.filter((action) => action.placement === side);
+  if (sideActions.length === 0 && slot === undefined) {
+    return {};
+  }
+  const name = SIDES[side];
+  if (platform === 'ios') {
+    if (sideActions.length === 0) {
+      return { [`header${name}`]: slot, [`unstable_header${name}Items`]: undefined };
+    }
+    return {
+      [`header${name}`]: undefined,
+      [`unstable_header${name}Items`]: () => [
+        ...(slot === undefined ? [] : [{ type: 'custom', element: slot() }]),
+        ...sideActions.map(toNativeItem),
+      ],
+    };
+  }
+  return {
+    [`header${name}`]: () => (
+      <View style={{ alignItems: 'center', columnGap: 4, flexDirection: 'row' }}>
+        {slot === undefined ? null : slot()}
+        {sideActions.map((action) => action.render())}
+      </View>
+    ),
+  };
+}
+
+// The native search bar's options from a Screen's headerSearch: its text events carry the text
+// in nativeEvent.text. searchBarRef lets the screen focus it (autoFocus).
+function getSearchOptions({ headerSearch, searchBarRef }) {
+  if (headerSearch === undefined) {
+    return undefined;
+  }
+  return {
+    autoFocus: headerSearch.autoFocus,
+    hideWhenScrolling: headerSearch.hideWhenScrolling,
+    onCancelButtonPress: () => headerSearch.onCancel(),
+    onChangeText: (event) => headerSearch.onChangeText(event.nativeEvent.text),
+    onSearchButtonPress: (event) => headerSearch.onSearch(event.nativeEvent.text),
+    placeholder: headerSearch.placeholder,
+    ref: searchBarRef,
+  };
+}
+
+// A Screen with a backgroundTint on iOS: a clear bar the page scrolls under, so the tint shows
+// behind the status bar, the bar, the large title and the search field. iOS 26's glass bar is
+// clear already, with the system's scroll edge effect under it once the page scrolls; before
+// iOS 26 the bar stays clear at the scroll edge (the large title's appearance, which a standard
+// title's scroll edge takes too) and takes the system chrome material once content scrolls
+// under it. Elsewhere the bar is the stack's own: the options are set to undefined, since
+// navigation.setOptions merges, so a tint that goes gives the bar back.
+function getTintOptions({ backgroundTint, platform, platformVersion }) {
+  if (backgroundTint !== true || platform !== 'ios') {
+    return {
+      headerBlurEffect: undefined,
+      headerLargeStyle: undefined,
+      headerTransparent: undefined,
+    };
+  }
+  if (Number.parseInt(`${platformVersion}`, 10) >= 26) {
+    return { headerBlurEffect: undefined, headerLargeStyle: undefined, headerTransparent: true };
+  }
+  return {
+    headerBlurEffect: 'systemChromeMaterial',
+    headerLargeStyle: { backgroundColor: 'transparent' },
+    headerTransparent: true,
+  };
+}
+
+/**
+ * The native stack options for a Screen page's header options (client-native screen/Screen.js):
+ * the title (a large title on iOS that collapses into the bar as the page scrolls), the
+ * presentation, a native search bar, and the header's slots and icon buttons at their natural
+ * size, as native bar buttons on iOS. A page with a headerBottom hides the bar's own hairline:
+ * the pinned strip under the bar draws one under itself. A page with a backgroundTint has a clear
+ * bar on iOS (getTintOptions).
+ *
+ * @param {Object} params
+ * @param {Object} params.options What the Screen reported.
+ * @param {string} params.platform Platform.OS.
+ * @param {string|number} [params.platformVersion] Platform.Version: iOS gives a string, "26.0".
+ * @param {Object} params.searchBarRef The ref the search bar's commands (focus) are set on.
+ */
+function getStackOptions({ options, platform, platformVersion, searchBarRef }) {
+  const {
+    backgroundTint,
+    headerActions,
+    headerBottom,
+    headerLeft,
+    headerRight,
+    headerSearch,
+    largeTitle,
+    presentation,
+    title,
+  } = options;
+  return {
+    headerBackVisible: true,
+    // Undefined keeps the stack's own default.
+    headerShadowVisible: headerBottom === true ? false : undefined,
+    headerLargeTitleEnabled: largeTitle,
+    headerLargeTitleShadowVisible: false,
+    headerSearchBarOptions: getSearchOptions({ headerSearch, searchBarRef }),
+    presentation: getPresentation(presentation),
+    title: title ?? '',
+    ...getSideOptions({ actions: headerActions, platform, side: 'left', slot: headerLeft }),
+    ...getSideOptions({ actions: headerActions, platform, side: 'right', slot: headerRight }),
+    ...getTintOptions({ backgroundTint, platform, platformVersion }),
+  };
+}
+
+export default getStackOptions;

package/src/navigation/getTabHref.js

@@ -0,0 +1,45 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import getFrame from './getFrame.js';
+
+/**
+ * The router href of the tab whose page is at `path`, with the query as the tab's params, or null
+ * when no tab shows that page (a stack or drawer frame, or a page no tab has). A tab's own page is
+ * shown on its tab, never stacked on another tab's screens, so the tab bar shows the tab that
+ * holds the page on screen.
+ *
+ * @param {Object} params
+ * @param {string} params.path The page path, without the leading "/".
+ * @param {string} [params.query] The query string, without "?".
+ * @param {Object} params.root The app's mobile root.
+ * @returns {string|null}
+ */
+function getTabHref({ path, query, root }) {
+  const frame = getFrame(root?.menus);
+  if (frame.kind !== 'tabs') {
+    return null;
+  }
+  const slotIndex = frame.items.findIndex(
+    (item) => root.pageIndex.find((entry) => entry.pageId === item.pageId)?.path === path
+  );
+  if (slotIndex === -1) {
+    return null;
+  }
+  return `/(t${slotIndex})${query ? `?${query}` : ''}`;
+}
+
+export default getTabHref;

package/src/navigation/getTabIcons.js

@@ -0,0 +1,43 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { getSfSymbol } from '@lowdefy/client-native';
+
+/**
+ * How each tab of a tabs frame draws its icon: on iOS, an SF Symbol (the item's `sfSymbol`, or
+ * the symbol mapped from its Lucide or semantic icon name); otherwise, or for an icon with no
+ * symbol, its Lucide icon as an image (TabIconImages), from the icon data the build adds to the
+ * item. A tab with no icon has none.
+ *
+ * @param {Object} params
+ * @param {Object[]} params.items The tabs frame's items.
+ * @param {string} params.platform Platform.OS.
+ * @returns {Object[]} Per item, `{ pageId, sf, iconData }`: `sf` an SF Symbol name or null, and
+ *   `iconData` the data to draw as an image, or null.
+ */
+function getTabIcons({ items, platform }) {
+  return items.map((item) => {
+    const sf =
+      platform === 'ios' ? getSfSymbol({ icon: item.icon, sfSymbol: item.sfSymbol }) : null;
+    return {
+      iconData: sf === null ? item.iconData ?? null : null,
+      pageId: item.pageId,
+      sf,
+    };
+  });
+}
+
+export default getTabIcons;

package/src/navigation/isPageUnderHeader.js

@@ -0,0 +1,46 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+/**
+ * Whether a Screen page scrolls under its navigation bar, as the native stack lays it out: on iOS
+ * 26 and later the bar is clear Liquid Glass over the page; before that, iOS makes the bar
+ * translucent over the page for a large title or a search bar, and a Screen with a backgroundTint
+ * has a clear bar over the page (getStackOptions). Otherwise (and on Android) the page
+ * sits below the bar. A page under the bar starts its content at the bar's bottom edge with
+ * automatic content insets, so a headerBottom pins under the bar at the header height; a page
+ * below the bar pins it at the top of its scroll view.
+ *
+ * @param {Object} params
+ * @param {Object} params.options The Screen's header options (client-native screen/Screen.js).
+ * @param {string} params.platform Platform.OS.
+ * @param {string|number} params.platformVersion Platform.Version: iOS gives a string, "26.0".
+ * @returns {boolean}
+ */
+function isPageUnderHeader({ options, platform, platformVersion }) {
+  if (platform !== 'ios') {
+    return false;
+  }
+  if (Number.parseInt(`${platformVersion}`, 10) >= 26) {
+    return true;
+  }
+  return (
+    options.backgroundTint === true ||
+    options.largeTitle === true ||
+    options.headerSearch !== undefined
+  );
+}
+
+export default isPageUnderHeader;