one 1.1.320 → 1.1.321

package/dist/cjs/router/router.js

@@ -0,0 +1,345 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var router_exports = {};
+__export(router_exports, {
+  canDismiss: () => canDismiss,
+  canGoBack: () => canGoBack,
+  cleanup: () => cleanup,
+  dismiss: () => dismiss,
+  dismissAll: () => dismissAll,
+  getRouteInfo: () => getRouteInfo,
+  getSortedRoutes: () => getSortedRoutes,
+  goBack: () => goBack,
+  hasAttemptedToHideSplash: () => hasAttemptedToHideSplash,
+  initialState: () => initialState,
+  initialize: () => initialize,
+  linkTo: () => linkTo,
+  linking: () => linking,
+  navigate: () => navigate,
+  navigationRef: () => navigationRef,
+  preloadRoute: () => preloadRoute,
+  preloadingLoader: () => preloadingLoader,
+  push: () => push,
+  replace: () => replace,
+  rootComponent: () => rootComponent,
+  rootState: () => rootState,
+  rootStateSnapshot: () => rootStateSnapshot,
+  routeInfo: () => routeInfo,
+  routeInfoSnapshot: () => routeInfoSnapshot,
+  routeNode: () => routeNode,
+  setLoadingState: () => setLoadingState,
+  setParams: () => setParams,
+  snapshot: () => snapshot,
+  subscribeToLoadingState: () => subscribeToLoadingState,
+  subscribeToRootState: () => subscribeToRootState,
+  subscribeToStore: () => subscribeToStore,
+  updateState: () => updateState,
+  useOneRouter: () => useOneRouter,
+  useStoreRootState: () => useStoreRootState,
+  useStoreRouteInfo: () => useStoreRouteInfo
+});
+module.exports = __toCommonJS(router_exports);
+var import_native = require("@react-navigation/native"), Linking = __toESM(require("expo-linking"), 1), import_non_secure = require("nanoid/non-secure"), import_react = require("react"), import_react_native = require("react-native-web"), import_cleanUrl = require("../cleanUrl"), import_getPathFromState = require("../fork/getPathFromState"), import_getStateFromPath = require("../fork/getStateFromPath"), import_getLinkingConfig = require("../getLinkingConfig"), import_getRoutes = require("../getRoutes"), import_href = require("../link/href"), import_path = require("../link/path"), import_matchers = require("../matchers"), import_sortRoutes = require("../sortRoutes"), import_useScreens = require("../useScreens"), import_assertIsReady = require("../utils/assertIsReady"), import_dynamicImport = require("../utils/dynamicImport"), import_removeSearch = require("../utils/removeSearch"), import_url = require("../utils/url"), import_getNormalizedStatePath = require("./getNormalizedStatePath"), import_lastAction = require("./lastAction");
+let routeNode = null, rootComponent, linking, hasAttemptedToHideSplash = !1, initialState, rootState, nextState, routeInfo, splashScreenAnimationFrame, navigationRef = null, navigationRefSubscription;
+const rootStateSubscribers = /* @__PURE__ */ new Set(), loadingStateSubscribers = /* @__PURE__ */ new Set(), storeSubscribers = /* @__PURE__ */ new Set();
+function initialize(context, ref, initialLocation) {
+  if (cleanUpState(), routeNode = (0, import_getRoutes.getRoutes)(context, {
+    ignoreEntryPoints: !0,
+    platform: import_react_native.Platform.OS
+  }), rootComponent = routeNode ? (0, import_useScreens.getQualifiedRouteComponent)(routeNode) : import_react.Fragment, !routeNode && process.env.NODE_ENV === "production")
+    throw new Error("No routes found");
+  navigationRef = ref, setupLinking(initialLocation), subscribeToNavigationChanges();
+}
+function cleanUpState() {
+  initialState = void 0, rootState = void 0, nextState = void 0, routeInfo = void 0, linking = void 0, navigationRefSubscription?.(), rootStateSubscribers.clear(), storeSubscribers.clear();
+}
+function setupLinking(initialLocation) {
+  routeNode && (linking = (0, import_getLinkingConfig.getLinkingConfig)(routeNode), initialLocation && (linking.getInitialURL = () => initialLocation.toString(), initialState = linking.getStateFromPath?.(
+    initialLocation.pathname + (initialLocation.search || ""),
+    linking.config
+  ))), initialState ? (rootState = initialState, routeInfo = getRouteInfo(initialState)) : routeInfo = {
+    unstable_globalHref: "",
+    pathname: "",
+    isIndex: !1,
+    params: {},
+    segments: []
+  };
+}
+function subscribeToNavigationChanges() {
+  navigationRefSubscription = navigationRef.addListener("state", (data) => {
+    const state = data.data.state;
+    hasAttemptedToHideSplash || (hasAttemptedToHideSplash = !0, splashScreenAnimationFrame = requestAnimationFrame(() => {
+    })), nextOptions && (state.linkOptions = nextOptions, nextOptions = null);
+    let shouldUpdateSubscribers = nextState === state;
+    if (nextState = void 0, state && state !== rootState && (updateState(state, void 0), shouldUpdateSubscribers = !0), shouldUpdateSubscribers)
+      for (const subscriber of rootStateSubscribers)
+        subscriber(state);
+  }), updateSnapshot();
+  for (const subscriber of storeSubscribers)
+    subscriber();
+}
+function navigate(url, options) {
+  return linkTo((0, import_href.resolveHref)(url), "NAVIGATE", options);
+}
+function push(url, options) {
+  return linkTo((0, import_href.resolveHref)(url), "PUSH", options);
+}
+function dismiss(count) {
+  navigationRef?.dispatch(import_native.StackActions.pop(count));
+}
+function replace(url, options) {
+  return linkTo((0, import_href.resolveHref)(url), "REPLACE", options);
+}
+function setParams(params = {}) {
+  return (0, import_assertIsReady.assertIsReady)(navigationRef), navigationRef?.current?.setParams(
+    // @ts-expect-error
+    params
+  );
+}
+function dismissAll() {
+  navigationRef?.dispatch(import_native.StackActions.popToTop());
+}
+function goBack() {
+  (0, import_assertIsReady.assertIsReady)(navigationRef), navigationRef?.current?.goBack();
+}
+function canGoBack() {
+  return navigationRef.isReady() ? navigationRef?.current?.canGoBack() ?? !1 : !1;
+}
+function canDismiss() {
+  let state = rootState;
+  for (; state; ) {
+    if (state.type === "stack" && state.routes.length > 1)
+      return !0;
+    if (state.index === void 0)
+      return !1;
+    state = state.routes?.[state.index]?.state;
+  }
+  return !1;
+}
+function getSortedRoutes() {
+  if (!routeNode)
+    throw new Error("No routes");
+  return routeNode.children.filter((route) => !route.internal).sort(import_sortRoutes.sortRoutes);
+}
+function updateState(state, nextStateParam = state) {
+  rootState = state, nextState = nextStateParam;
+  const nextRouteInfo = getRouteInfo(state);
+  (0, import_getPathFromState.deepEqual)(routeInfo, nextRouteInfo) || (routeInfo = nextRouteInfo);
+}
+function getRouteInfo(state) {
+  return getRouteInfoFromState(
+    (state2, asPath) => (0, import_getPathFromState.getPathDataFromState)(state2, {
+      screens: [],
+      ...linking?.config,
+      preserveDynamicRoutes: asPath,
+      preserveGroups: asPath
+    }),
+    state
+  );
+}
+function getRouteInfoFromState(getPathFromState, state, baseUrl) {
+  const { path } = getPathFromState(state, !1), qualified = getPathFromState(state, !0);
+  return {
+    unstable_globalHref: path,
+    pathname: (0, import_getStateFromPath.stripBaseUrl)(path, baseUrl).split("?")[0],
+    isIndex: isIndexPath(state),
+    ...(0, import_getNormalizedStatePath.getNormalizedStatePath)(qualified, baseUrl)
+  };
+}
+function subscribeToRootState(subscriber) {
+  return rootStateSubscribers.add(subscriber), () => {
+    rootStateSubscribers.delete(subscriber);
+  };
+}
+function subscribeToStore(subscriber) {
+  return storeSubscribers.add(subscriber), () => {
+    storeSubscribers.delete(subscriber);
+  };
+}
+function subscribeToLoadingState(subscriber) {
+  return loadingStateSubscribers.add(subscriber), () => {
+    loadingStateSubscribers.delete(subscriber);
+  };
+}
+function setLoadingState(state) {
+  for (const listener of loadingStateSubscribers)
+    listener(state);
+}
+let currentSnapshot = null;
+function updateSnapshot() {
+  currentSnapshot = getSnapshot();
+}
+function snapshot() {
+  return currentSnapshot;
+}
+function getSnapshot() {
+  return {
+    linkTo,
+    routeNode,
+    rootComponent,
+    linking,
+    hasAttemptedToHideSplash,
+    initialState,
+    rootState,
+    nextState,
+    routeInfo,
+    splashScreenAnimationFrame,
+    navigationRef,
+    navigationRefSubscription,
+    rootStateSubscribers,
+    storeSubscribers
+  };
+}
+function rootStateSnapshot() {
+  return rootState;
+}
+function routeInfoSnapshot() {
+  return routeInfo;
+}
+function useOneRouter() {
+  return (0, import_react.useSyncExternalStore)(subscribeToStore, snapshot, snapshot);
+}
+function syncStoreRootState() {
+  if (!navigationRef)
+    throw new Error("No navigationRef, possible duplicate One dep");
+  if (navigationRef.isReady()) {
+    const currentState = navigationRef.getRootState();
+    rootState !== currentState && updateState(currentState);
+  }
+}
+function useStoreRootState() {
+  return syncStoreRootState(), (0, import_react.useSyncExternalStore)(subscribeToRootState, rootStateSnapshot, rootStateSnapshot);
+}
+function useStoreRouteInfo() {
+  return syncStoreRootState(), (0, import_react.useSyncExternalStore)(subscribeToRootState, routeInfoSnapshot, routeInfoSnapshot);
+}
+function isIndexPath(state) {
+  const route = getActualLastRoute(state.routes[state.index ?? state.routes.length - 1]);
+  return route.state ? isIndexPath(route.state) : route.name === "index" ? !0 : route.params && "screen" in route.params ? route.params.screen === "index" : !!route.name.match(/.+\/index$/);
+}
+function getActualLastRoute(routeLike) {
+  if (routeLike.name[0] === "(" && routeLike.state?.routes) {
+    const routes = routeLike.state.routes;
+    return getActualLastRoute(routes[routes.length - 1]);
+  }
+  return routeLike;
+}
+function cleanup() {
+  splashScreenAnimationFrame && cancelAnimationFrame(splashScreenAnimationFrame);
+}
+const preloadingLoader = {};
+function setupPreload(href) {
+  preloadingLoader[href] || (preloadingLoader[href] = async () => {
+    const [_preload, loader] = await Promise.all([
+      (0, import_dynamicImport.dynamicImport)((0, import_cleanUrl.getPreloadPath)(href)),
+      (0, import_dynamicImport.dynamicImport)((0, import_cleanUrl.getLoaderPath)(href))
+    ]);
+    try {
+      return await (await loader).loader?.();
+    } catch (err) {
+      return console.error(`Error preloading loader: ${err}`), null;
+    }
+  });
+}
+function preloadRoute(href) {
+  process.env.NODE_ENV !== "development" && (setupPreload(href), typeof preloadingLoader[href] == "function" && preloadingLoader[href]());
+}
+async function linkTo(href, event, options) {
+  if (href[0] === "#")
+    return;
+  if ((0, import_url.shouldLinkExternally)(href)) {
+    Linking.openURL(href);
+    return;
+  }
+  (0, import_assertIsReady.assertIsReady)(navigationRef);
+  const current = navigationRef.current;
+  if (current == null)
+    throw new Error(
+      "Couldn't find a navigation object. Is your component inside NavigationContainer?"
+    );
+  if (!linking)
+    throw new Error("Attempted to link to route when no routes are present");
+  if ((0, import_lastAction.setLastAction)(), href === ".." || href === "../") {
+    current.goBack();
+    return;
+  }
+  if (href.startsWith(".")) {
+    let base = routeInfo?.segments?.map((segment) => {
+      if (!segment.startsWith("[")) return segment;
+      if (segment.startsWith("[...")) {
+        segment = segment.slice(4, -1);
+        const params = routeInfo?.params?.[segment];
+        return Array.isArray(params) ? params.join("/") : params?.split(",")?.join("/") ?? "";
+      }
+      return segment = segment.slice(1, -1), routeInfo?.params?.[segment];
+    }).filter(Boolean).join("/") ?? "/";
+    routeInfo?.isIndex || (base += "/.."), href = (0, import_path.resolve)(base, href);
+  }
+  const state = linking.getStateFromPath(href, linking.config);
+  if (!state || state.routes.length === 0) {
+    console.error("Could not generate a valid navigation state for the given path: " + href), console.error("linking.config", linking.config), console.error("routes", getSortedRoutes());
+    return;
+  }
+  setLoadingState("loading"), globalThis.__vxrntodopath = (0, import_removeSearch.removeSearch)(href), preloadRoute(href);
+  const rootState2 = navigationRef.getRootState(), action = getNavigateAction(state, rootState2, event);
+  nextOptions = options ?? null, (0, import_react.startTransition)(() => {
+    const current2 = navigationRef.getCurrentRoute();
+    navigationRef.dispatch(action);
+    let warningTm;
+    const interval = setInterval(() => {
+      const next = navigationRef.getCurrentRoute();
+      current2 !== next && setTimeout(() => {
+        setLoadingState("loaded");
+      }), clearTimeout(warningTm), clearTimeout(interval);
+    }, 16);
+    process.env.NODE_ENV === "development" && (warningTm = setTimeout(() => {
+      console.warn("Routing took more than 8 seconds");
+    }, 1e3));
+  });
+}
+let nextOptions = null;
+function getNavigateAction(actionState, navigationState, type = "NAVIGATE") {
+  let actionStateRoute;
+  for (; actionState && navigationState; ) {
+    const stateRoute = navigationState.routes[navigationState.index];
+    actionStateRoute = actionState.routes[actionState.routes.length - 1];
+    const childState = actionStateRoute.state, nextNavigationState = stateRoute.state, dynamicName = (0, import_matchers.matchDynamicName)(actionStateRoute.name);
+    if (actionStateRoute.name !== stateRoute.name || !childState || !nextNavigationState || dynamicName && actionStateRoute.params?.[dynamicName] !== stateRoute.params?.[dynamicName])
+      break;
+    actionState = childState, navigationState = nextNavigationState;
+  }
+  const rootPayload = { params: {} };
+  let payload = rootPayload, params = payload.params;
+  for (; actionStateRoute; )
+    Object.assign(params, { ...actionStateRoute.params }), payload.screen = actionStateRoute.name, payload.params = { ...actionStateRoute.params }, actionStateRoute = actionStateRoute.state?.routes[actionStateRoute.state?.routes.length - 1], payload.params ??= {}, payload = payload.params, params = payload;
+  return type === "PUSH" && ((0, import_lastAction.setLastAction)(), type = "NAVIGATE", navigationState.type === "stack" && (rootPayload.key = `${rootPayload.name}-${(0, import_non_secure.nanoid)()}`)), type === "REPLACE" && navigationState.type === "tab" && (type = "JUMP_TO"), {
+    type,
+    target: navigationState.key,
+    payload: {
+      key: rootPayload.key,
+      name: rootPayload.screen,
+      params: rootPayload.params
+    }
+  };
+}
+//# sourceMappingURL=router.js.map

package/dist/cjs/router/serverLocationContext.js

@@ -0,0 +1,22 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var serverLocationContext_exports = {};
+__export(serverLocationContext_exports, {
+  ServerLocationContext: () => ServerLocationContext
+});
+module.exports = __toCommonJS(serverLocationContext_exports);
+var import_react = require("react");
+const ServerLocationContext = (0, import_react.createContext)(void 0);
+//# sourceMappingURL=serverLocationContext.js.map

package/dist/cjs/router/useInitializeOneRouter.js

@@ -0,0 +1,43 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var useInitializeOneRouter_exports = {};
+__export(useInitializeOneRouter_exports, {
+  resetState: () => resetState,
+  useInitializeOneRouter: () => useInitializeOneRouter
+});
+module.exports = __toCommonJS(useInitializeOneRouter_exports);
+var import_native = require("@react-navigation/native"), import_router = require("./router"), routerStore = __toESM(require("./router"), 1);
+let initialized = !1;
+function useInitializeOneRouter(context, initialLocation) {
+  const navigationRef = (0, import_native.useNavigationContainerRef)();
+  return initialized || ((0, import_router.initialize)(context, navigationRef, initialLocation), initialized = !0), routerStore;
+}
+function resetState() {
+  initialized = !1, resetReactNavigationContexts();
+}
+globalThis.__vxrnresetState = resetState;
+function resetReactNavigationContexts() {
+  const contexts = "__react_navigation__elements_contexts";
+  globalThis[contexts] = /* @__PURE__ */ new Map();
+}
+//# sourceMappingURL=useInitializeOneRouter.js.map

package/dist/cjs/serve.js

@@ -0,0 +1,184 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var serve_exports = {};
+__export(serve_exports, {
+  serve: () => serve
+});
+module.exports = __toCommonJS(serve_exports);
+var import_polyfills_server = require("./polyfills-server"), import_fs_extra = __toESM(require("fs-extra"), 1), import_node_path = require("node:path"), import_vxrn = require("vxrn");
+process.on("uncaughtException", (err) => {
+  console.error("[one] Uncaught exception", err?.stack || err);
+});
+async function serve(args = {}) {
+  const buildInfo = await import_fs_extra.default.readJSON("dist/buildInfo.json");
+  process.env.ONE_CACHE_KEY = buildInfo.constants.CACHE_KEY;
+  const { labelProcess } = await import("./cli/label-process"), { removeUndefined } = await import("./utils/removeUndefined"), { loadUserOneOptions } = await import("./vite/one");
+  labelProcess("serve"), (0, import_vxrn.loadEnv)("production");
+  const oneOptions = await loadUserOneOptions("serve");
+  return process.env.VXRN_REACT_19 = "1", await (0, import_vxrn.serve)({
+    server: {
+      // fallback to one plugin
+      ...oneOptions.server,
+      // override with any flags given to cli
+      ...removeUndefined({
+        port: args.port ? +args.port : void 0,
+        host: args.host,
+        compress: args.compress,
+        platform: args.platform,
+        cacheHeaders: args.cacheHeaders
+      }),
+      async beforeStart(options, app) {
+        await oneOptions.server?.beforeStart?.(options, app), await oneServe(oneOptions, options, buildInfo, app);
+      }
+    }
+  });
+}
+async function oneServe(options, vxrnOptions, buildInfo, app) {
+  const { createHandleRequest } = await import("./createHandleRequest"), { isResponse } = await import("./utils/isResponse"), { isStatusRedirect } = await import("./utils/isStatus"), { resolveAPIRequest } = await import("./vite/resolveAPIRequest"), isAPIRequest = /* @__PURE__ */ new WeakMap(), root = vxrnOptions.root || ".", redirects = options.web?.redirects;
+  if (redirects)
+    for (const redirect of redirects)
+      app.get(redirect.source, (context) => {
+        const destinationUrl = redirect.destination.replace(/:\w+/g, (param) => {
+          const paramName = param.substring(1);
+          return context.req.param(paramName) || "";
+        });
+        return context.redirect(destinationUrl, redirect.permanent ? 301 : 302);
+      });
+  if (!buildInfo)
+    throw new Error("No build info found, have you run build?");
+  const { routeMap, builtRoutes } = buildInfo, routeToBuildInfo = {};
+  for (const route of builtRoutes) {
+    routeToBuildInfo[route.cleanPath] = route;
+    const bracketRoutePath = route.cleanPath.split("/").map((part) => part[0] === ":" ? `[${part.slice(1)}]` : part).join("/");
+    routeToBuildInfo[bracketRoutePath] = route;
+  }
+  const serverOptions = {
+    ...options,
+    root
+  }, render = (await import((0, import_vxrn.getServerEntry)(serverOptions))).default.render, apiCJS = options.build?.api?.outputFormat === "cjs", handleRequest = createHandleRequest(
+    {},
+    {
+      async handleAPI({ route, request, loaderProps }) {
+        const apiFile = (0, import_node_path.join)(
+          process.cwd(),
+          "dist",
+          "api",
+          route.page.replace("[", "_").replace("]", "_") + (apiCJS ? ".cjs" : ".js")
+        );
+        return isAPIRequest.set(request, !0), resolveAPIRequest(
+          async () => {
+            try {
+              return await import(apiFile);
+            } catch (err) {
+              return console.error(`
+ [one] Error importing API route at ${apiFile}:
+
+  ${err}
+
+  If this is an import error, you can likely fix this by adding this dependency to
+  the "optimizeDeps.include" array in your vite.config.ts.
+
+  \u{1F41E} For a better error message run "node" and enter:
+
+  import('${apiFile}')
+
+`), {};
+            }
+          },
+          request,
+          loaderProps?.params || {}
+        );
+      },
+      async handleSSR({ route, url, loaderProps }) {
+        if (route.type === "ssr") {
+          const buildInfo2 = routeToBuildInfo[route.page];
+          if (!buildInfo2)
+            throw new Error(
+              `No buildinfo found for ${url}, route: ${route.page}, in keys: ${Object.keys(routeToBuildInfo)}`
+            );
+          try {
+            const loaderData = await (await import(buildInfo2.serverJsPath)).loader?.(loaderProps), preloads = buildInfo2.preloads, headers = new Headers();
+            return headers.set("content-type", "text/html"), new Response(
+              await render({
+                loaderData,
+                loaderProps,
+                path: loaderProps?.path || "/",
+                preloads
+              }),
+              {
+                headers
+              }
+            );
+          } catch (err) {
+            console.error(`[one] Error rendering SSR route ${route.page}
+
+  ${err?.stack ?? err}
+
+  url: ${url}`);
+          }
+        }
+      }
+    }
+  ), htmlFiles = {};
+  for (const key in routeMap)
+    routeToBuildInfo[key]?.type !== "ssr" && (htmlFiles[key] = await import_fs_extra.default.readFile((0, import_node_path.join)("dist/client", routeMap[key]), "utf-8"));
+  app.use(async (context, next) => {
+    const html = htmlFiles[context.req.path];
+    if (html)
+      return context.html(html);
+    try {
+      const request = context.req.raw, response = await handleRequest.handler(request);
+      if (response) {
+        if (isResponse(response)) {
+          if (isStatusRedirect(response.status)) {
+            const location = `${response.headers.get("location") || ""}`;
+            return response.headers.forEach((value, key) => {
+              context.header(key, value);
+            }), context.redirect(location, response.status);
+          }
+          if (isAPIRequest.get(request))
+            try {
+              response.headers.set("Cache-Control", "no-store");
+            } catch (err) {
+              console.info(
+                `Error udpating cache header on api route "${context.req.path}" to no-store, it is ${response.headers.get("cache-control")}, continue`,
+                err
+              );
+            }
+          return response;
+        }
+        return context.json(
+          response,
+          200,
+          isAPIRequest.get(request) ? {
+            "Cache-Control": "no-store"
+          } : void 0
+        );
+      }
+    } catch (err) {
+      console.error(` [one] Error handling request: ${err.stack}`);
+    }
+    await next();
+  });
+}
+//# sourceMappingURL=serve.js.map

package/dist/cjs/server/createRoutesManifest.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var createRoutesManifest_exports = {};
+__export(createRoutesManifest_exports, {
+  createRoutesManifest: () => createRoutesManifest
+});
+module.exports = __toCommonJS(createRoutesManifest_exports);
+var import_getRoutes = require("../getRoutes"), import_getServerManifest = require("./getServerManifest");
+function createMockModuleWithContext(map = []) {
+  const contextModule = (key) => ({ default() {
+  } });
+  return Object.defineProperty(contextModule, "keys", {
+    value: () => map
+  }), contextModule;
+}
+function createRoutesManifest(paths, options) {
+  const routeTree = (0, import_getRoutes.getRoutes)(createMockModuleWithContext(paths), {
+    ...options,
+    preserveApiRoutes: !0,
+    ignoreRequireErrors: !0,
+    ignoreEntryPoints: !0,
+    platform: "web"
+  });
+  if (!routeTree)
+    throw new Error(`No route tree found in paths: ${JSON.stringify(paths)}`);
+  return (0, import_getServerManifest.getServerManifest)(routeTree);
+}
+//# sourceMappingURL=createRoutesManifest.js.map