@onekeyfe/react-native-native-overlay 3.0.162-alpha.268

package/ios/NativeOverlayWindowManager.swift

@@ -0,0 +1,194 @@
+import UIKit
+
+/// Levels mirror `OVERLAY_LEVEL_ORDER`. Each active level gets its own
+/// window so that order between levels never depends on show order.
+enum NativeOverlayLevel: String, CaseIterable {
+  case modal
+  case hardware
+  case secure
+  case toast
+  case lock
+  case debug
+
+  /// Mirrors `OVERLAY_LEVEL_ORDER`.
+  var order: Int {
+    switch self {
+    case .modal: return 100
+    case .hardware: return 200
+    case .secure: return 300
+    case .toast: return 400
+    case .lock: return 500
+    case .debug: return 900
+    }
+  }
+
+  var windowLevel: UIWindow.Level {
+    switch self {
+    // Above the app window (and every VC it presents), below system alerts.
+    case .modal: return UIWindow.Level(rawValue: UIWindow.Level.normal.rawValue + 10)
+    case .hardware: return UIWindow.Level(rawValue: UIWindow.Level.normal.rawValue + 20)
+    case .secure: return UIWindow.Level(rawValue: UIWindow.Level.normal.rawValue + 30)
+    case .toast: return UIWindow.Level(rawValue: UIWindow.Level.normal.rawValue + 40)
+    // Above React Native's Alert window (alert + 1) and perf overlays.
+    case .lock: return UIWindow.Level(rawValue: UIWindow.Level.alert.rawValue + 10)
+    case .debug: return UIWindow.Level(rawValue: UIWindow.Level.alert.rawValue + 20)
+    }
+  }
+}
+
+/// Lets touches that miss every overlay fall through to lower windows.
+final class NativeOverlayPassthroughWindow: UIWindow {
+  override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+    let hit = super.hitTest(point, with: event)
+    if hit === self || hit === rootViewController?.view {
+      return nil
+    }
+    return hit
+  }
+
+  // React Native reads the window dimensions from the key window, and a
+  // touched level window becomes key. A rotation reported while it is key
+  // (or while it is hidden with a stale frame) leaves JS with the wrong
+  // window size. Once the sizes settle, re-report through the frame
+  // observer React Native keeps on the app window.
+  override var frame: CGRect {
+    didSet {
+      if isKeyWindow && oldValue.size != frame.size {
+        refreshReactNativeDimensions()
+      }
+    }
+  }
+
+  override func resignKey() {
+    super.resignKey()
+    refreshReactNativeDimensions()
+  }
+
+  private func refreshReactNativeDimensions() {
+    guard let appWindow = (rootViewController as? NativeOverlayRootViewController)?.appWindow
+    else { return }
+    DispatchQueue.main.async { [weak appWindow] in
+      guard let appWindow else { return }
+      // Assigning the frame fires React Native's KVO, which recomputes the
+      // dimensions from the current key window.
+      let frame = appWindow.frame
+      appWindow.frame = frame
+    }
+  }
+}
+
+/// Status bar and orientation follow the app window underneath, because
+/// `childForStatusBarStyle` cannot reach across windows.
+final class NativeOverlayRootViewController: UIViewController {
+  weak var appWindow: UIWindow?
+
+  private var appTopController: UIViewController? {
+    var controller = appWindow?.rootViewController
+    while let presented = controller?.presentedViewController, !presented.isBeingDismissed {
+      controller = presented
+    }
+    // Never answer with ourselves: asking it would recurse forever.
+    return controller === self ? nil : controller
+  }
+
+  override func loadView() {
+    let root = UIView()
+    root.backgroundColor = .clear
+    view = root
+  }
+
+  /// Apps without view-controller-based status bar appearance set one
+  /// app-wide style (React Native's StatusBar does). Level windows above the
+  /// status bar (`lock`, `debug`) still get asked, so answer with that style.
+  private static let viewControllerBasedAppearance =
+    (Bundle.main.object(forInfoDictionaryKey: "UIViewControllerBasedStatusBarAppearance") as? Bool) ?? true
+
+  override var preferredStatusBarStyle: UIStatusBarStyle {
+    if !Self.viewControllerBasedAppearance {
+      return UIApplication.shared.statusBarStyle
+    }
+    return appTopController?.preferredStatusBarStyle ?? .default
+  }
+
+  override var prefersStatusBarHidden: Bool {
+    appTopController?.prefersStatusBarHidden ?? false
+  }
+
+  override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
+    appTopController?.supportedInterfaceOrientations ?? .all
+  }
+}
+
+final class NativeOverlayWindowManager {
+  static let shared = NativeOverlayWindowManager()
+
+  private struct SceneKey: Hashable {
+    let id: ObjectIdentifier
+  }
+
+  private var windows: [SceneKey: [NativeOverlayLevel: NativeOverlayPassthroughWindow]] = [:]
+
+  /// The level window for `level` in the scene of `appWindow`, shown on demand.
+  /// Non-sheet entries are added directly to it so they interleave by insertion
+  /// order with UIKit presentation containers of sheets in the same level.
+  func window(for level: NativeOverlayLevel, appWindow hostWindow: UIWindow) -> UIWindow? {
+    // An overlay opened from inside another overlay (a popover in a password
+    // prompt) is hosted in a level window; follow it back to the app window.
+    let appWindow =
+      ((hostWindow as? NativeOverlayPassthroughWindow)?.rootViewController
+        as? NativeOverlayRootViewController)?.appWindow ?? hostWindow
+    guard let scene = appWindow.windowScene else { return nil }
+    let key = SceneKey(id: ObjectIdentifier(scene))
+    pruneDisconnectedScenes()
+    var sceneWindows = windows[key] ?? [:]
+    let window: NativeOverlayPassthroughWindow
+    if let existing = sceneWindows[level] {
+      window = existing
+    } else {
+      window = NativeOverlayPassthroughWindow(windowScene: scene)
+      window.windowLevel = level.windowLevel
+      window.backgroundColor = .clear
+      window.rootViewController = NativeOverlayRootViewController()
+      sceneWindows[level] = window
+      windows[key] = sceneWindows
+    }
+    (window.rootViewController as? NativeOverlayRootViewController)?.appWindow = appWindow
+    if window.isHidden {
+      window.frame = scene.coordinateSpace.bounds
+      window.isHidden = false
+      window.rootViewController?.setNeedsStatusBarAppearanceUpdate()
+    }
+    return window
+  }
+
+  /// Top of the level window's presentation chain; sheets of one level stack here.
+  func presenter(in window: UIWindow) -> UIViewController? {
+    var controller = window.rootViewController
+    while let presented = controller?.presentedViewController, !presented.isBeingDismissed {
+      controller = presented
+    }
+    return controller
+  }
+
+  /// Hides a level window once nothing is shown in it, and hands key status
+  /// back to the app window if an input in the overlay had taken it.
+  func entryRemoved(from window: UIWindow?) {
+    guard let window = window as? NativeOverlayPassthroughWindow,
+          let root = window.rootViewController else { return }
+    let hasEntries = window.subviews.contains { $0 is NativeOverlayEntryView }
+    let presented = root.presentedViewController
+    guard !hasEntries, presented == nil || presented?.isBeingDismissed == true else { return }
+    let wasKey = window.isKeyWindow
+    window.isHidden = true
+    if wasKey {
+      (root as? NativeOverlayRootViewController)?.appWindow?.makeKey()
+    }
+  }
+
+  private func pruneDisconnectedScenes() {
+    let connected = Set(
+      UIApplication.shared.connectedScenes.map { SceneKey(id: ObjectIdentifier($0)) }
+    )
+    windows = windows.filter { connected.contains($0.key) }
+  }
+}

package/ios/RCTNativeOverlayComponentView.h

@@ -0,0 +1,11 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTNativeOverlayComponentView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+#endif

package/ios/RCTNativeOverlayComponentView.mm

@@ -0,0 +1,193 @@
+#import "RCTNativeOverlayComponentView.h"
+
+#include <cmath>
+
+#import <react/renderer/components/RNCNativeOverlay/NativeOverlayComponentDescriptor.h>
+#import <react/renderer/components/RNCNativeOverlay/EventEmitters.h>
+#import <react/renderer/components/RNCNativeOverlay/Props.h>
+#import <react/renderer/components/RNCNativeOverlay/RCTComponentViewHelpers.h>
+
+#import <React/RCTComponent.h>
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+#import <React/RCTSurfaceTouchHandler.h>
+
+#if __has_include(<NativeOverlay/NativeOverlay-Swift.h>)
+#import <NativeOverlay/NativeOverlay-Swift.h>
+#elif __has_include("NativeOverlay/NativeOverlay-Swift.h")
+#import "NativeOverlay/NativeOverlay-Swift.h"
+#else
+#import "NativeOverlay-Swift.h"
+#endif
+
+using namespace facebook::react;
+
+static NSString *RNCNativeOverlayLevelString(RNCNativeOverlayLevel level)
+{
+  switch (level) {
+    case RNCNativeOverlayLevel::Hardware:
+      return @"hardware";
+    case RNCNativeOverlayLevel::Secure:
+      return @"secure";
+    case RNCNativeOverlayLevel::Toast:
+      return @"toast";
+    case RNCNativeOverlayLevel::Lock:
+      return @"lock";
+    case RNCNativeOverlayLevel::Debug:
+      return @"debug";
+    case RNCNativeOverlayLevel::Modal:
+    default:
+      return @"modal";
+  }
+}
+
+static NSString *RNCNativeOverlayPresentationString(RNCNativeOverlayPresentation presentation)
+{
+  switch (presentation) {
+    case RNCNativeOverlayPresentation::Toast:
+      return @"toast";
+    case RNCNativeOverlayPresentation::Fullscreen:
+      return @"fullscreen";
+    case RNCNativeOverlayPresentation::Sheet:
+      return @"sheet";
+    case RNCNativeOverlayPresentation::Anchored:
+      return @"anchored";
+    case RNCNativeOverlayPresentation::Center:
+    default:
+      return @"center";
+  }
+}
+
+@implementation RCTNativeOverlayComponentView {
+  NativeOverlayContainerView *_containerView;
+  RCTSurfaceTouchHandler *_touchHandler;
+  RNCNativeOverlayShadowNode::ConcreteState::Shared _state;
+  CGPoint _contentOffset;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNCNativeOverlayComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNCNativeOverlayProps>();
+    _props = defaultProps;
+
+    _containerView = [NativeOverlayContainerView new];
+    _touchHandler = [RCTSurfaceTouchHandler new];
+    _containerView.touchHandler = _touchHandler;
+    self.contentView = _containerView;
+
+    __weak auto weakSelf = self;
+    _containerView.onContentOffsetChanged = ^(CGPoint offset) {
+      auto strongSelf = weakSelf;
+      if (!strongSelf) return;
+      strongSelf->_contentOffset = offset;
+      [strongSelf pushContentOffset];
+    };
+    _containerView.onPresented = ^(NSDictionary *body) {
+      auto strongSelf = weakSelf;
+      if (!strongSelf) return;
+      auto emitter = std::static_pointer_cast<const RNCNativeOverlayEventEmitter>(strongSelf->_eventEmitter);
+      if (!emitter) return;
+      NSNumber *stackOrder = body[@"stackOrder"] ?: @0;
+      emitter->onPresented({.stackOrder = stackOrder.intValue});
+    };
+    _containerView.onDismissed = ^(NSDictionary *body) {
+      auto strongSelf = weakSelf;
+      if (!strongSelf) return;
+      auto emitter = std::static_pointer_cast<const RNCNativeOverlayEventEmitter>(strongSelf->_eventEmitter);
+      if (!emitter) return;
+      NSString *reason = body[@"reason"] ?: @"system";
+      emitter->onDismissed({.reason = std::string(reason.UTF8String)});
+    };
+    _containerView.onRequestDismiss = ^(NSDictionary *body) {
+      auto strongSelf = weakSelf;
+      if (!strongSelf) return;
+      auto emitter = std::static_pointer_cast<const RNCNativeOverlayEventEmitter>(strongSelf->_eventEmitter);
+      if (!emitter) return;
+      NSString *reason = body[@"reason"] ?: @"back";
+      emitter->onRequestDismiss({.reason = std::string(reason.UTF8String)});
+    };
+  }
+  return self;
+}
+
++ (BOOL)shouldBeRecycled
+{
+  return NO;
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index
+{
+  [_containerView insertChild:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index
+{
+  [_containerView removeChild:childComponentView];
+  [childComponentView removeFromSuperview];
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &newProps = *std::static_pointer_cast<RNCNativeOverlayProps const>(props);
+
+  _containerView.level = RNCNativeOverlayLevelString(newProps.level);
+  _containerView.presentation = RNCNativeOverlayPresentationString(newProps.presentation);
+  _containerView.scope = newProps.scope == RNCNativeOverlayScope::Page ? @"page" : @"global";
+  _containerView.hostKey = [NSString stringWithUTF8String:newProps.hostKey.c_str()];
+  _containerView.ownerKey = [NSString stringWithUTF8String:newProps.ownerKey.c_str()];
+  _containerView.stackOrder = newProps.stackOrder;
+  _containerView.blocking = newProps.blocking;
+  _containerView.dismissOnBackPress = newProps.dismissOnBackPress;
+  _containerView.dismissOnBackdropPress = newProps.dismissOnBackdropPress;
+  _containerView.backdropColor = RCTUIColorFromSharedColor(newProps.backdropColor);
+  _containerView.sheetHeight = newProps.sheetHeight;
+  _containerView.sheetCornerRadius = newProps.sheetCornerRadius;
+  _containerView.showHandle = newProps.showHandle;
+  _containerView.sheetBackgroundColor = RCTUIColorFromSharedColor(newProps.sheetBackgroundColor);
+  _containerView.dismissOnPanDown = newProps.dismissOnPanDown;
+  _containerView.animationConfig = [NSString stringWithUTF8String:newProps.animationConfig.c_str()];
+  _containerView.visible = newProps.visible;
+  [_containerView commitConfiguration];
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateState:(State::Shared const &)state oldState:(State::Shared const &)oldState
+{
+  _state = std::static_pointer_cast<RNCNativeOverlayShadowNode::ConcreteState const>(state);
+  [self pushContentOffset];
+}
+
+// Keeps the shadow node's measurement origin at the content's window origin.
+- (void)pushContentOffset
+{
+  if (!_state) {
+    return;
+  }
+  const auto current = _state->getData().contentOffset;
+  if (std::abs(current.x - _contentOffset.x) < 0.5 && std::abs(current.y - _contentOffset.y) < 0.5) {
+    return;
+  }
+  _state->updateState(NativeOverlayState{facebook::react::Point{.x = _contentOffset.x, .y = _contentOffset.y}});
+}
+
+- (void)invalidate
+{
+  [_containerView invalidate];
+  [super invalidate];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNCNativeOverlayCls(void)
+{
+  return RCTNativeOverlayComponentView.class;
+}

package/ios/RCTNativeOverlayPageHostComponentView.h

@@ -0,0 +1,11 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTNativeOverlayPageHostComponentView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+#endif

package/ios/RCTNativeOverlayPageHostComponentView.mm

@@ -0,0 +1,64 @@
+#import "RCTNativeOverlayPageHostComponentView.h"
+
+#import <react/renderer/components/RNCNativeOverlay/ComponentDescriptors.h>
+#import <react/renderer/components/RNCNativeOverlay/Props.h>
+#import <react/renderer/components/RNCNativeOverlay/RCTComponentViewHelpers.h>
+
+#import <React/RCTComponent.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#if __has_include(<NativeOverlay/NativeOverlay-Swift.h>)
+#import <NativeOverlay/NativeOverlay-Swift.h>
+#elif __has_include("NativeOverlay/NativeOverlay-Swift.h")
+#import "NativeOverlay/NativeOverlay-Swift.h"
+#else
+#import "NativeOverlay-Swift.h"
+#endif
+
+using namespace facebook::react;
+
+@implementation RCTNativeOverlayPageHostComponentView {
+  NativeOverlayPageHostView *_hostView;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNCNativeOverlayPageHostComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNCNativeOverlayPageHostProps>();
+    _props = defaultProps;
+    _hostView = [NativeOverlayPageHostView new];
+    self.contentView = _hostView;
+  }
+  return self;
+}
+
++ (BOOL)shouldBeRecycled
+{
+  return NO;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &newProps = *std::static_pointer_cast<RNCNativeOverlayPageHostProps const>(props);
+  _hostView.hostKey = [NSString stringWithUTF8String:newProps.hostKey.c_str()];
+  [_hostView setSuspendedOwners:[NSString stringWithUTF8String:newProps.suspendedOwners.c_str()]];
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)invalidate
+{
+  [_hostView invalidate];
+  [super invalidate];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNCNativeOverlayPageHostCls(void)
+{
+  return RCTNativeOverlayPageHostComponentView.class;
+}

package/lib/module/NativeOverlayNativeComponent.ts

@@ -0,0 +1,61 @@
+import { codegenNativeComponent } from 'react-native';
+
+import type {
+  CodegenTypes,
+  ColorValue,
+  HostComponent,
+  ViewProps,
+} from 'react-native';
+type INativeOverlayDismissedEvent = Readonly<{
+  reason: string;
+}>;
+
+type INativeOverlayRequestDismissEvent = Readonly<{
+  reason: string;
+}>;
+
+type INativeOverlayPresentedEvent = Readonly<{
+  stackOrder: CodegenTypes.Int32;
+}>;
+
+export interface INativeOverlayNativeProps extends ViewProps {
+  /** Present when true; play the exit animation and emit onDismissed when it turns false. */
+  visible: boolean;
+  level?: CodegenTypes.WithDefault<
+    'modal' | 'hardware' | 'secure' | 'toast' | 'lock' | 'debug',
+    'modal'
+  >;
+  presentation?: CodegenTypes.WithDefault<
+    'center' | 'toast' | 'fullscreen' | 'sheet' | 'anchored',
+    'center'
+  >;
+  scope?: CodegenTypes.WithDefault<'global' | 'page', 'global'>;
+  /** `page` scope: the `OverlayPageHost` to render in and the owning page. */
+  hostKey?: CodegenTypes.WithDefault<string, ''>;
+  ownerKey?: CodegenTypes.WithDefault<string, ''>;
+  /** Order inside the level; higher renders above. */
+  stackOrder?: CodegenTypes.WithDefault<CodegenTypes.Int32, 0>;
+  /** Swallow touches that miss the content instead of passing them through. */
+  blocking?: CodegenTypes.WithDefault<boolean, true>;
+  dismissOnBackPress?: CodegenTypes.WithDefault<boolean, true>;
+  dismissOnBackdropPress?: CodegenTypes.WithDefault<boolean, false>;
+  backdropColor?: ColorValue;
+  /** `sheet` presentation: resolved content height in points. */
+  sheetHeight?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  sheetCornerRadius?: CodegenTypes.WithDefault<CodegenTypes.Double, 24>;
+  showHandle?: CodegenTypes.WithDefault<boolean, false>;
+  sheetBackgroundColor?: ColorValue;
+  dismissOnPanDown?: CodegenTypes.WithDefault<boolean, true>;
+  /** JSON of the resolved animation (`IResolvedOverlayAnimation`). */
+  animationConfig?: CodegenTypes.WithDefault<string, ''>;
+  onPresented?: CodegenTypes.DirectEventHandler<INativeOverlayPresentedEvent>;
+  onDismissed?: CodegenTypes.DirectEventHandler<INativeOverlayDismissedEvent>;
+  onRequestDismiss?: CodegenTypes.DirectEventHandler<INativeOverlayRequestDismissEvent>;
+}
+
+// The shadow node is hand-written (common/cpp): it carries the on-screen
+// content offset so `measure` reports where native presented the content.
+export default codegenNativeComponent<INativeOverlayNativeProps>(
+  'RNCNativeOverlay',
+  { interfaceOnly: true }
+) as HostComponent<INativeOverlayNativeProps>;

package/lib/module/NativeOverlayPageHostNativeComponent.ts

@@ -0,0 +1,13 @@
+import { codegenNativeComponent } from 'react-native';
+
+import type { HostComponent, ViewProps } from 'react-native';
+
+export interface INativeOverlayPageHostNativeProps extends ViewProps {
+  hostKey: string;
+  /** Owners whose entries are hidden, newline separated. */
+  suspendedOwners?: string;
+}
+
+export default codegenNativeComponent<INativeOverlayPageHostNativeProps>(
+  'RNCNativeOverlayPageHost'
+) as HostComponent<INativeOverlayPageHostNativeProps>;

package/lib/module/OverlayErrors.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export class OverlayRequestError extends Error {
+  name = 'OverlayRequestError';
+}
+//# sourceMappingURL=OverlayErrors.js.map

package/lib/module/OverlayErrors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["OverlayRequestError","Error","name"],"sourceRoot":"../../src","sources":["OverlayErrors.ts"],"mappings":";;AAAA,OAAO,MAAMA,mBAAmB,SAASC,KAAK,CAAC;EACpCC,IAAI,GAAG,qBAAqB;AACvC","ignoreList":[]}

package/lib/module/OverlayLevelContext.js

@@ -0,0 +1,27 @@
+"use strict";
+
+import { createContext, useContext } from 'react';
+import { OVERLAY_LEVEL_ORDER } from "./OverlayLevels.js";
+const OverlayLevelContext = /*#__PURE__*/createContext(undefined);
+
+/** Provided by `OverlayView` to its content. */
+export const OverlayLevelProvider = OverlayLevelContext.Provider;
+
+/** The level of the overlay this component renders in, if any. */
+export function useEnclosingOverlayLevel() {
+  return useContext(OverlayLevelContext);
+}
+
+/**
+ * The level for an overlay opened from inside another one (a popover in a
+ * password prompt, a tooltip on the lock screen): never below the overlay it
+ * is opened from, or it would render underneath it.
+ */
+export function useNestedOverlayLevel(minimum = 'modal') {
+  const enclosing = useEnclosingOverlayLevel();
+  if (!enclosing) {
+    return minimum;
+  }
+  return OVERLAY_LEVEL_ORDER[enclosing] > OVERLAY_LEVEL_ORDER[minimum] ? enclosing : minimum;
+}
+//# sourceMappingURL=OverlayLevelContext.js.map

package/lib/module/OverlayLevelContext.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createContext","useContext","OVERLAY_LEVEL_ORDER","OverlayLevelContext","undefined","OverlayLevelProvider","Provider","useEnclosingOverlayLevel","useNestedOverlayLevel","minimum","enclosing"],"sourceRoot":"../../src","sources":["OverlayLevelContext.tsx"],"mappings":";;AAAA,SAASA,aAAa,EAAEC,UAAU,QAAQ,OAAO;AAEjD,SAASC,mBAAmB,QAAQ,oBAAiB;AAIrD,MAAMC,mBAAmB,gBAAGH,aAAa,CAA4BI,SAAS,CAAC;;AAE/E;AACA,OAAO,MAAMC,oBAAoB,GAAGF,mBAAmB,CAACG,QAAQ;;AAEhE;AACA,OAAO,SAASC,wBAAwBA,CAAA,EAA8B;EACpE,OAAON,UAAU,CAACE,mBAAmB,CAAC;AACxC;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASK,qBAAqBA,CACnCC,OAAsB,GAAG,OAAO,EACjB;EACf,MAAMC,SAAS,GAAGH,wBAAwB,CAAC,CAAC;EAC5C,IAAI,CAACG,SAAS,EAAE;IACd,OAAOD,OAAO;EAChB;EACA,OAAOP,mBAAmB,CAACQ,SAAS,CAAC,GAAGR,mBAAmB,CAACO,OAAO,CAAC,GAChEC,SAAS,GACTD,OAAO;AACb","ignoreList":[]}

package/lib/module/OverlayLevels.js

@@ -0,0 +1,33 @@
+"use strict";
+
+export const OVERLAY_LEVEL_ORDER = {
+  modal: 100,
+  hardware: 200,
+  secure: 300,
+  toast: 400,
+  lock: 500,
+  debug: 900
+};
+export const OVERLAY_LEVELS = Object.keys(OVERLAY_LEVEL_ORDER).toSorted((a, b) => OVERLAY_LEVEL_ORDER[a] - OVERLAY_LEVEL_ORDER[b]);
+const NON_BLOCKING_LEVELS = new Set(['toast', 'debug']);
+export function isBlockingLevel(level) {
+  return !NON_BLOCKING_LEVELS.has(level);
+}
+
+/**
+ * Web z-index bands of the level layer roots (`document.body` children). In-page
+ * content that must rise above a level (a drag clone over a dialog) uses a
+ * value just above that level's base.
+ */
+export const OVERLAY_WEB_Z_INDEX_BASE = {
+  modal: 100_000,
+  hardware: 120_000,
+  secure: 160_000,
+  toast: 1_000_000,
+  lock: 100_000_000,
+  debug: 100_000_005
+};
+
+/** Page-scope entries always render below every global entry. */
+export const OVERLAY_WEB_PAGE_Z_INDEX_BASE = 1000;
+//# sourceMappingURL=OverlayLevels.js.map

package/lib/module/OverlayLevels.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["OVERLAY_LEVEL_ORDER","modal","hardware","secure","toast","lock","debug","OVERLAY_LEVELS","Object","keys","toSorted","a","b","NON_BLOCKING_LEVELS","Set","isBlockingLevel","level","has","OVERLAY_WEB_Z_INDEX_BASE","OVERLAY_WEB_PAGE_Z_INDEX_BASE"],"sourceRoot":"../../src","sources":["OverlayLevels.ts"],"mappings":";;AAEA,OAAO,MAAMA,mBAAkD,GAAG;EAChEC,KAAK,EAAE,GAAG;EACVC,QAAQ,EAAE,GAAG;EACbC,MAAM,EAAE,GAAG;EACXC,KAAK,EAAE,GAAG;EACVC,IAAI,EAAE,GAAG;EACTC,KAAK,EAAE;AACT,CAAC;AAED,OAAO,MAAMC,cAAwC,GACnDC,MAAM,CAACC,IAAI,CAACT,mBAAmB,CAAC,CAChCU,QAAQ,CAAC,CAACC,CAAC,EAAEC,CAAC,KAAKZ,mBAAmB,CAACW,CAAC,CAAC,GAAGX,mBAAmB,CAACY,CAAC,CAAC,CAAC;AAErE,MAAMC,mBAA+C,GAAG,IAAIC,GAAG,CAAC,CAC9D,OAAO,EACP,OAAO,CACR,CAAC;AAEF,OAAO,SAASC,eAAeA,CAACC,KAAoB,EAAW;EAC7D,OAAO,CAACH,mBAAmB,CAACI,GAAG,CAACD,KAAK,CAAC;AACxC;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAME,wBAAuD,GAAG;EACrEjB,KAAK,EAAE,OAAO;EACdC,QAAQ,EAAE,OAAO;EACjBC,MAAM,EAAE,OAAO;EACfC,KAAK,EAAE,SAAS;EAChBC,IAAI,EAAE,WAAW;EACjBC,KAAK,EAAE;AACT,CAAC;;AAED;AACA,OAAO,MAAMa,6BAA6B,GAAG,IAAI","ignoreList":[]}

package/lib/module/OverlayPageHost.js

@@ -0,0 +1,24 @@
+"use strict";
+
+import { StyleSheet } from 'react-native';
+import NativeOverlayPageHost from './NativeOverlayPageHostNativeComponent';
+import { useSuspendedPageOwners } from "./useSuspendedPageOwners.js";
+
+/**
+ * Renders page-scope overlays of one root route. Place it as the last child
+ * of the root-route screen, after its navigator, so page overlays cover the
+ * native header and tab bar of every page in that route.
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export function OverlayPageHost({
+  hostKey
+}) {
+  const suspendedOwners = useSuspendedPageOwners(hostKey);
+  return /*#__PURE__*/_jsx(NativeOverlayPageHost, {
+    hostKey: hostKey,
+    suspendedOwners: suspendedOwners.join('\n'),
+    pointerEvents: "box-none",
+    style: StyleSheet.absoluteFill
+  });
+}
+//# sourceMappingURL=OverlayPageHost.js.map

package/lib/module/OverlayPageHost.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["StyleSheet","NativeOverlayPageHost","useSuspendedPageOwners","jsx","_jsx","OverlayPageHost","hostKey","suspendedOwners","join","pointerEvents","style","absoluteFill"],"sourceRoot":"../../src","sources":["OverlayPageHost.tsx"],"mappings":";;AAAA,SAASA,UAAU,QAAQ,cAAc;AAEzC,OAAOC,qBAAqB,MAAM,wCAAwC;AAC1E,SAASC,sBAAsB,QAAQ,6BAA0B;;AAEjE;AACA;AACA;AACA;AACA;AAJA,SAAAC,GAAA,IAAAC,IAAA;AAKA,OAAO,SAASC,eAAeA,CAAC;EAAEC;AAA6B,CAAC,EAAE;EAChE,MAAMC,eAAe,GAAGL,sBAAsB,CAACI,OAAO,CAAC;EACvD,oBACEF,IAAA,CAACH,qBAAqB;IACpBK,OAAO,EAAEA,OAAQ;IACjBC,eAAe,EAAEA,eAAe,CAACC,IAAI,CAAC,IAAI,CAAE;IAC5CC,aAAa,EAAC,UAAU;IACxBC,KAAK,EAAEV,UAAU,CAACW;EAAa,CAChC,CAAC;AAEN","ignoreList":[]}