one/dist/esm/router/web/WebStackView.native.js

One is a new React Framework that makes Vite serve both native and web.

"use client";

import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
import { StackActions } from "@react-navigation/native";
import { NativeStackView } from "@react-navigation/native-stack";
import { Fragment, useCallback, useRef, useState } from "react";
import { convertStackStateToNonOverlayState, findLastNonOverlayIndex, isOverlayPresentation } from "./stackStateUtils.native.js";
import { useStackRender } from "./ScreenRenderContext.native.js";
function resolveOverlayRender(options, contextRender) {
  var _ref;
  var _options_render;
  return (_ref = options === null || options === void 0 ? void 0 : (_options_render = options.render) === null || _options_render === void 0 ? void 0 : _options_render.web) !== null && _ref !== void 0 ? _ref : contextRender === null || contextRender === void 0 ? void 0 : contextRender.web;
}
function WebStackView(param) {
  var {
    state,
    navigation,
    descriptors,
    describe
  } = param;
  var contextRender = useStackRender();
  var persistentSlotsRef = useRef(/* @__PURE__ */new Map());
  var _iteratorNormalCompletion = true,
    _didIteratorError = false,
    _iteratorError = void 0;
  try {
    for (var _iterator = state.routes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var route = _step.value;
      var desc = descriptors[route.key];
      if (!desc) continue;
      var {
        options
      } = desc;
      if (!options.keepMounted) continue;
      if (!isOverlayPresentation(options)) continue;
      var Render = resolveOverlayRender(options, contextRender);
      if (!Render) continue;
      if (persistentSlotsRef.current.has(route.name)) continue;
      persistentSlotsRef.current.set(route.name, {
        routeName: route.name,
        Render,
        options,
        content: desc.render()
      });
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return != null) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }
  var isOverlayCandidate = function (options2) {
    return isOverlayPresentation(options2) && resolveOverlayRender(options2 !== null && options2 !== void 0 ? options2 : void 0, contextRender) !== void 0;
  };
  var nonOverlay = convertStackStateToNonOverlayState(state, descriptors, isOverlayCandidate);
  var underlyingState = {
    ...state,
    routes: nonOverlay.routes,
    index: nonOverlay.index
  };
  var lastNonOverlay = findLastNonOverlayIndex(state, descriptors, isOverlayCandidate);
  var trailingOverlays = state.routes.slice(lastNonOverlay + 1);
  var focusedOverlayNames = new Set(trailingOverlays.map(function (r) {
    return r.name;
  }));
  var regularOverlays = trailingOverlays.filter(function (r) {
    var _descriptors_r_key;
    return !((_descriptors_r_key = descriptors[r.key]) === null || _descriptors_r_key === void 0 ? void 0 : _descriptors_r_key.options.keepMounted);
  });
  return /* @__PURE__ */_jsxs(Fragment, {
    children: [/* @__PURE__ */_jsx(NativeStackView, {
      state: underlyingState,
      descriptors,
      navigation,
      describe
    }), regularOverlays.map(function (route2) {
      return /* @__PURE__ */_jsx(OverlayHost, {
        route: route2,
        descriptor: descriptors[route2.key],
        contextRender,
        open: true,
        onDismiss: function () {
          return navigation.dispatch({
            ...StackActions.pop(),
            source: route2.key,
            target: state.key
          });
        }
      }, route2.key);
    }),
    /* Persistent slots - render once each, never unmount. `open` toggles
    based on whether the route is the current trailing overlay. */
    Array.from(persistentSlotsRef.current.values()).map(function (slot) {
      return /* @__PURE__ */_jsx(PersistentOverlayHost, {
        slot,
        open: focusedOverlayNames.has(slot.routeName),
        onDismiss: function () {
          var live = state.routes.find(function (r) {
            return r.name === slot.routeName;
          });
          if (live) {
            navigation.dispatch({
              ...StackActions.pop(),
              source: live.key,
              target: state.key
            });
          }
        }
      }, slot.routeName);
    })]
  });
}
function OverlayHost(param) {
  var {
    route,
    descriptor,
    contextRender,
    open,
    onDismiss
  } = param;
  var _options_gestureEnabled;
  var dismiss = useStableCallback(onDismiss);
  var options = descriptor.options;
  var Render = resolveOverlayRender(options, contextRender);
  var content = descriptor.render();
  if (!Render || !isOverlayPresentation(options)) {
    return /* @__PURE__ */_jsx(Fragment, {
      children: content
    });
  }
  var renderProps = {
    routeKey: route.key,
    routeName: route.name,
    presentation: options.presentation,
    open,
    dismiss,
    dismissible: (_options_gestureEnabled = options.gestureEnabled) !== null && _options_gestureEnabled !== void 0 ? _options_gestureEnabled : true,
    sheetAllowedDetents: options.sheetAllowedDetents,
    sheetGrabberVisible: options.sheetGrabberVisible,
    sheetCornerRadius: options.sheetCornerRadius,
    sheetInitialDetentIndex: options.sheetInitialDetentIndex,
    sheetLargestUndimmedDetentIndex: options.sheetLargestUndimmedDetentIndex,
    sheetExpandsWhenScrolledToEdge: options.sheetExpandsWhenScrolledToEdge,
    children: content
  };
  return /* @__PURE__ */_jsx(Render, {
    ...renderProps
  });
}
function PersistentOverlayHost(param) {
  var {
    slot,
    open,
    onDismiss
  } = param;
  var _options_gestureEnabled;
  var dismiss = useStableCallback(onDismiss);
  var {
    Render,
    options,
    content,
    routeName
  } = slot;
  var renderProps = {
    routeKey: `__keepMounted:${routeName}`,
    routeName,
    presentation: options.presentation,
    open,
    dismiss,
    dismissible: (_options_gestureEnabled = options.gestureEnabled) !== null && _options_gestureEnabled !== void 0 ? _options_gestureEnabled : true,
    sheetAllowedDetents: options.sheetAllowedDetents,
    sheetGrabberVisible: options.sheetGrabberVisible,
    sheetCornerRadius: options.sheetCornerRadius,
    sheetInitialDetentIndex: options.sheetInitialDetentIndex,
    sheetLargestUndimmedDetentIndex: options.sheetLargestUndimmedDetentIndex,
    sheetExpandsWhenScrolledToEdge: options.sheetExpandsWhenScrolledToEdge,
    children: content
  };
  return /* @__PURE__ */_jsx(Render, {
    ...renderProps
  });
}
function useStableCallback(fn) {
  var [ref] = useState(function () {
    return {
      current: fn
    };
  });
  ref.current = fn;
  return useCallback(function () {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    return ref.current(...args);
  }, [ref]);
}
export { OverlayHost, WebStackView, resolveOverlayRender };
//# sourceMappingURL=WebStackView.native.js.map