one 1.1.319 → 1.1.321

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

package/dist/cjs/server/getServerManifest.js

@@ -0,0 +1,109 @@
+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 getServerManifest_exports = {};
+__export(getServerManifest_exports, {
+  getServerManifest: () => getServerManifest,
+  parseParam: () => parseParam
+});
+module.exports = __toCommonJS(getServerManifest_exports);
+var import_matchers = require("../matchers"), import_sortRoutes = require("../sortRoutes");
+function isNotFoundRoute(route) {
+  return !!(route.dynamic && route.dynamic[route.dynamic.length - 1].notFound);
+}
+function getServerManifest(route) {
+  function getFlatNodes(route2, layouts) {
+    if (route2.children.length)
+      return route2.children.flatMap((child) => getFlatNodes(child, [...layouts || [], route2]));
+    let key;
+    return route2.type === "api" ? key = (0, import_matchers.getContextKey)(route2.contextKey).replace(/\/index$/, "") || "/" : key = layouts?.flatMap((route3) => {
+      const key2 = (0, import_matchers.getContextKey)(route3.route).replace(/\/index$/, "") || "/";
+      return key2 === "/" || key2.startsWith("/(") ? [] : [key2];
+    }) + (0, import_matchers.getContextKey)(route2.route).replace(/\/index$/, "") || "/", [[key, { ...route2, layouts }]];
+  }
+  const flat = getFlatNodes(route).sort(([, a], [, b]) => (0, import_sortRoutes.sortRoutes)(b, a)).reverse(), pathToRoute = {};
+  for (const [path, route2] of flat)
+    pathToRoute[path] && (console.warn(`
+[one] \u274C Duplicate routes error`), console.warn("  Multiple routes at the same path! One route will always win over the other."), console.warn(`    path: ${path}`), console.warn(`    first route: ${pathToRoute[path].contextKey}`), console.warn(`    second route: ${route2.contextKey}
+`)), pathToRoute[path] = route2;
+  const apiRoutes = [], pageRoutes = [];
+  for (const [path, node] of flat) {
+    if (node.type === "api") {
+      apiRoutes.push(getGeneratedNamedRouteRegex(path, node));
+      continue;
+    }
+    pageRoutes.push(getGeneratedNamedRouteRegex(path, node));
+  }
+  return {
+    apiRoutes,
+    pageRoutes
+  };
+}
+function getGeneratedNamedRouteRegex(normalizedRoute, node) {
+  return {
+    ...getNamedRouteRegex(normalizedRoute, node),
+    generated: !0,
+    isNotFound: isNotFoundRoute(node)
+  };
+}
+function getNamedRouteRegex(normalizedRoute, node) {
+  const result = getNamedRegex(normalizedRoute);
+  return {
+    file: node.contextKey,
+    page: (0, import_matchers.getContextKey)(node.route),
+    type: node.type,
+    namedRegex: result.namedRegex,
+    routeKeys: result.routeKeys,
+    layouts: node.layouts
+  };
+}
+function buildGetSafeRouteKey() {
+  let currentCharCode = 96, currentLength = 1;
+  return () => {
+    let result = "", incrementNext = !0;
+    for (let i = 0; i < currentLength; i++)
+      incrementNext && (currentCharCode++, currentCharCode > 122 ? (currentCharCode = 97, incrementNext = !0) : incrementNext = !1), result = String.fromCharCode(currentCharCode) + result;
+    return incrementNext && (currentLength++, currentCharCode = 96), result;
+  };
+}
+function removeTrailingSlash(route) {
+  return route.replace(/\/$/, "") || "/";
+}
+function getNamedRegex(route) {
+  const segments = removeTrailingSlash(route).slice(1).split("/"), getSafeRouteKey = buildGetSafeRouteKey(), routeKeys = {};
+  return {
+    namedRegex: `^${segments.map((segment, index) => {
+      if (segment === "+not-found" && index === segments.length - 1 && (segment = "[...not-found]"), /^\[.*\]$/.test(segment)) {
+        const { name, optional, repeat } = parseParam(segment);
+        let cleanedKey = name.replace(/\W/g, ""), invalidKey = !1;
+        return (cleanedKey.length === 0 || cleanedKey.length > 30) && (invalidKey = !0), Number.isNaN(Number.parseInt(cleanedKey.slice(0, 1), 10)) || (invalidKey = !0), cleanedKey in routeKeys && (invalidKey = !0), invalidKey && (cleanedKey = getSafeRouteKey()), routeKeys[cleanedKey] = name, repeat ? optional ? `(?:/(?<${cleanedKey}>.+?))?` : `/(?<${cleanedKey}>.+?)` : `/(?<${cleanedKey}>[^/]+?)`;
+      }
+      if (insideParensRegex.test(segment)) {
+        const groupName = (0, import_matchers.matchGroupName)(segment).split(",").map((group) => group.trim()).filter(Boolean);
+        return groupName.length > 1 ? `(?:/${`\\((?:${groupName.map(escapeStringRegexp).join("|")})\\)`})?` : `(?:/${escapeStringRegexp(segment)})?`;
+      }
+      return `/${escapeStringRegexp(segment)}`;
+    }).join("")}(?:/)?$`,
+    routeKeys
+  };
+}
+const insideBracketsRegex = /^\[.*\]$/, insideParensRegex = /^\(.*\)$/, tripleDotRegex = /^\.\.\./, replaceRegex = /[|\\{}()[\]^$+*?.-]/g, hasRegExpRegex = /[|\\{}()[\]^$+*?.-]/;
+function escapeStringRegexp(str) {
+  return hasRegExpRegex.test(str) ? str.replace(replaceRegex, "\\$&") : str;
+}
+function parseParam(param) {
+  let repeat = !1, optional = !1, name = param;
+  return insideBracketsRegex.test(name) && (optional = !0, name = name.slice(1, -1)), tripleDotRegex.test(name) && (repeat = !0, name = name.slice(3)), { name, repeat, optional };
+}
+//# sourceMappingURL=getServerManifest.js.map

package/dist/cjs/server-render.js

@@ -0,0 +1,42 @@
+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 server_render_exports = {};
+__export(server_render_exports, {
+  renderToString: () => renderToString
+});
+module.exports = __toCommonJS(server_render_exports);
+var import_server = __toESM(require("react-dom/server.browser"), 1);
+const renderToString = async (app, options) => {
+  const readableStream = await import_server.default.renderToReadableStream(app, {
+    bootstrapModules: options.preloads
+  });
+  return await readableStream.allReady, await streamToString(readableStream);
+};
+async function streamToString(stream) {
+  const decoder = new TextDecoder("utf-8", { fatal: !0 });
+  let result = "";
+  for await (const chunk of stream)
+    result += decoder.decode(chunk, { stream: !0 });
+  return result += decoder.decode(), result;
+}
+//# sourceMappingURL=server-render.js.map

package/dist/cjs/sortRoutes.js

@@ -0,0 +1,64 @@
+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 sortRoutes_exports = {};
+__export(sortRoutes_exports, {
+  sortRoutes: () => sortRoutes,
+  sortRoutesWithInitial: () => sortRoutesWithInitial
+});
+module.exports = __toCommonJS(sortRoutes_exports);
+var import_matchers = require("./matchers");
+function sortDynamicConvention(a, b) {
+  return a.deep && !b.deep ? 1 : !a.deep && b.deep ? -1 : 0;
+}
+function sortRoutes(a, b) {
+  if (a.dynamic && !b.dynamic)
+    return 1;
+  if (!a.dynamic && b.dynamic)
+    return -1;
+  if (a.dynamic && b.dynamic) {
+    if (a.dynamic.length !== b.dynamic.length)
+      return b.dynamic.length - a.dynamic.length;
+    for (let i = 0; i < a.dynamic.length; i++) {
+      const aDynamic = a.dynamic[i], bDynamic = b.dynamic[i];
+      if (aDynamic.notFound && bDynamic.notFound) {
+        const s2 = sortDynamicConvention(aDynamic, bDynamic);
+        if (s2)
+          return s2;
+      }
+      if (aDynamic.notFound && !bDynamic.notFound)
+        return 1;
+      if (!aDynamic.notFound && bDynamic.notFound)
+        return -1;
+      const s = sortDynamicConvention(aDynamic, bDynamic);
+      if (s)
+        return s;
+    }
+    return 0;
+  }
+  const aIndex = a.route === "index" || (0, import_matchers.matchGroupName)(a.route) != null, bIndex = b.route === "index" || (0, import_matchers.matchGroupName)(b.route) != null;
+  return aIndex && !bIndex ? -1 : !aIndex && bIndex ? 1 : a.route.length - b.route.length;
+}
+function sortRoutesWithInitial(initialRouteName) {
+  return (a, b) => {
+    if (initialRouteName) {
+      if (a.route === initialRouteName)
+        return -1;
+      if (b.route === initialRouteName)
+        return 1;
+    }
+    return sortRoutes(a, b);
+  };
+}
+//# sourceMappingURL=sortRoutes.js.map

package/dist/cjs/typed-routes/generateRouteTypes.js

@@ -0,0 +1,33 @@
+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 generateRouteTypes_exports = {};
+__export(generateRouteTypes_exports, {
+  generateRouteTypes: () => generateRouteTypes
+});
+module.exports = __toCommonJS(generateRouteTypes_exports);
+var import_fs_extra = __toESM(require("fs-extra"), 1), import_promises = require("node:fs/promises"), import_node_path = require("node:path"), import_useViteRoutes = require("../useViteRoutes"), import_globDir = require("../utils/globDir"), import_getTypedRoutesDeclarationFile = require("./getTypedRoutesDeclarationFile");
+async function generateRouteTypes(outFile) {
+  const routes = (0, import_globDir.globDir)("app").reduce((acc, cur) => (acc[cur] = {}, acc), {}), context = (0, import_useViteRoutes.globbedRoutesToRouteContext)(routes), declarations = (0, import_getTypedRoutesDeclarationFile.getTypedRoutesDeclarationFile)(context);
+  await import_fs_extra.default.ensureDir((0, import_node_path.dirname)(outFile)), await (0, import_promises.writeFile)(outFile, declarations);
+}
+//# sourceMappingURL=generateRouteTypes.js.map

package/dist/cjs/typed-routes/getTypedRoutesDeclarationFile.js

@@ -0,0 +1,83 @@
+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 getTypedRoutesDeclarationFile_exports = {};
+__export(getTypedRoutesDeclarationFile_exports, {
+  getTypedRoutesDeclarationFile: () => getTypedRoutesDeclarationFile
+});
+module.exports = __toCommonJS(getTypedRoutesDeclarationFile_exports);
+var import_getRoutes = require("../getRoutes"), import_matchers = require("../matchers");
+const CATCH_ALL = /\[\.\.\..+?\]/g, SLUG = /\[.+?\]/g;
+function getTypedRoutesDeclarationFile(ctx) {
+  const staticRoutes = /* @__PURE__ */ new Set(), dynamicRoutes = /* @__PURE__ */ new Set(), dynamicRouteContextKeys = /* @__PURE__ */ new Set();
+  return walkRouteNode(
+    (0, import_getRoutes.getRoutes)(ctx, {
+      platformRoutes: !1,
+      // We don't need to generate platform specific routes
+      ignoreEntryPoints: !0,
+      ignoreRequireErrors: !0
+      // importMode: 'async',
+    }),
+    "",
+    staticRoutes,
+    dynamicRoutes,
+    dynamicRouteContextKeys
+  ), `
+import type { OneRouter } from 'one'
+
+declare module 'one' {
+  export namespace OneRouter {
+    export interface __routes<T extends string = string> extends Record<string, unknown> {
+      StaticRoutes: ${setToUnionType(staticRoutes)}
+      DynamicRoutes: ${setToUnionType(dynamicRoutes)}
+      DynamicRouteTemplate: ${setToUnionType(dynamicRouteContextKeys)}
+      IsTyped: true
+    }
+  }
+}
+`.trim();
+}
+function walkRouteNode(routeNode, parentRoutePath, staticRoutes, dynamicRoutes, dynamicRouteContextKeys) {
+  if (routeNode) {
+    addRouteNode(routeNode, parentRoutePath, staticRoutes, dynamicRoutes, dynamicRouteContextKeys), parentRoutePath = `${(0, import_matchers.removeSupportedExtensions)(`${parentRoutePath}/${routeNode.route}`).replace(/\/?index$/, "")}`;
+    for (const child of routeNode.children)
+      walkRouteNode(child, parentRoutePath, staticRoutes, dynamicRoutes, dynamicRouteContextKeys);
+  }
+}
+function addRouteNode(routeNode, parentRoutePath, staticRoutes, dynamicRoutes, dynamicRouteContextKeys) {
+  if (!routeNode?.route || !(0, import_matchers.isTypedRoute)(routeNode.route)) return;
+  let routePath = `${parentRoutePath}/${(0, import_matchers.removeSupportedExtensions)(routeNode.route).replace(/\/?index$/, "")}`;
+  if (routePath.startsWith("/") || (routePath = `/${routePath}`), routeNode.dynamic)
+    for (const path of generateCombinations(routePath))
+      dynamicRouteContextKeys.add(path), dynamicRoutes.add(
+        `${path.replaceAll(CATCH_ALL, "${string}").replaceAll(SLUG, "${OneRouter.SingleRoutePart<T>}")}`
+      );
+  else
+    for (const combination of generateCombinations(routePath))
+      staticRoutes.add(combination);
+}
+const setToUnionType = (set) => set.size > 0 ? [...set].sort().map((s) => `\`${s}\``).join(" | ") : "never";
+function generateCombinations(pathname) {
+  const groups = pathname.split("/").filter((part) => part.startsWith("(") && part.endsWith(")")), combinations = [];
+  function generate(currentIndex, currentPath) {
+    if (currentIndex === groups.length) {
+      combinations.push(currentPath.replace(/\/{2,}/g, "/"));
+      return;
+    }
+    const group = groups[currentIndex], withoutGroup = currentPath.replace(`/${group}`, "");
+    generate(currentIndex + 1, withoutGroup), generate(currentIndex + 1, currentPath);
+  }
+  return generate(0, pathname), combinations;
+}
+//# sourceMappingURL=getTypedRoutesDeclarationFile.js.map

package/dist/cjs/types.js

@@ -0,0 +1,14 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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 types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/cjs/useFocusEffect.js

@@ -0,0 +1,79 @@
+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 useFocusEffect_exports = {};
+__export(useFocusEffect_exports, {
+  useFocusEffect: () => useFocusEffect
+});
+module.exports = __toCommonJS(useFocusEffect_exports);
+var React = __toESM(require("react"), 1), import_useLoadedNavigation = require("./link/useLoadedNavigation");
+function useFocusEffect(effect, do_not_pass_a_second_prop) {
+  const navigation = (0, import_useLoadedNavigation.useOptionalNavigation)();
+  do_not_pass_a_second_prop !== void 0 && console.error(`You passed a second argument to 'useFocusEffect', but it only accepts one argument. If you want to pass a dependency array, you can use 'React.useCallback':
+
+useFocusEffect(
+  React.useCallback(() => {
+    // Your code here
+  }, [depA, depB])
+);
+
+See usage guide: https://reactnavigation.org/docs/use-focus-effect`), React.useEffect(() => {
+    if (!navigation)
+      return;
+    let isFocused = !1, cleanup;
+    const callback = () => {
+      const destroy = effect();
+      if (destroy === void 0 || typeof destroy == "function")
+        return destroy;
+      if (process.env.NODE_ENV !== "production") {
+        let message = "An effect function must not return anything besides a function, which is used for clean-up.";
+        destroy === null ? message += " You returned 'null'. If your effect does not require clean-up, return 'undefined' (or nothing)." : typeof destroy.then == "function" ? message += `
+
+It looks like you wrote 'useFocusEffect(async () => ...)' or returned a Promise. Instead, write the async function inside your effect and call it immediately:
+
+useFocusEffect(
+  React.useCallback(() => {
+    async function fetchData() {
+      // You can await here
+      const response = await MyAPI.getData(someId);
+      // ...
+    }
+
+    fetchData();
+  }, [someId])
+);
+
+See usage guide: https://reactnavigation.org/docs/use-focus-effect` : message += ` You returned '${JSON.stringify(destroy)}'.`, console.error(message);
+      }
+    };
+    navigation.isFocused() && (cleanup = callback(), isFocused = !0);
+    const unsubscribeFocus = navigation.addListener("focus", () => {
+      isFocused || (cleanup !== void 0 && cleanup(), cleanup = callback(), isFocused = !0);
+    }), unsubscribeBlur = navigation.addListener("blur", () => {
+      cleanup !== void 0 && cleanup(), cleanup = void 0, isFocused = !1;
+    });
+    return () => {
+      cleanup !== void 0 && cleanup(), unsubscribeFocus(), unsubscribeBlur();
+    };
+  }, [effect, navigation]);
+}
+//# sourceMappingURL=useFocusEffect.js.map

package/dist/cjs/useLoader.js

@@ -0,0 +1,97 @@
+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 useLoader_exports = {};
+__export(useLoader_exports, {
+  useLoader: () => useLoader
+});
+module.exports = __toCommonJS(useLoader_exports);
+var import_react = require("react"), import_cleanUrl = require("./cleanUrl"), import_hooks = require("./hooks"), import_href = require("./link/href"), import_Route = require("./Route"), import_router = require("./router/router"), import_dynamicImport = require("./utils/dynamicImport"), import_weakKey = require("./utils/weakKey");
+const promises = {}, errors = {}, loadedData = {};
+function useLoader(loader) {
+  const preloadedProps = globalThis.__vxrnLoaderProps__;
+  if (typeof window > "u")
+    return useAsyncFn(
+      loader,
+      preloadedProps || {
+        params: (0, import_hooks.useActiveParams)()
+      }
+    );
+  const isNative = !1, routeNode = (0, import_Route.useRouteNode)(), params = (0, import_hooks.useParams)(), pathName = "/" + (0, import_href.resolveHref)({ pathname: routeNode?.route || "", params }).replace(/index$/, ""), currentPath = (isNative ? null : globalThis.__vxrntodopath) || // @zetavg: not sure why we're using `globalThis['__vxrntodopath']` here, but this breaks native when switching between tabs where the value stays with the previous path, so ignoring this on native
+  // TODO likely either not needed or needs proper path from server side
+  (typeof window < "u" ? window.location?.pathname || pathName : "/"), preloadedData = preloadedProps?.path === currentPath ? globalThis.__vxrnLoaderData__ : void 0, currentData = (0, import_react.useRef)(preloadedData);
+  if ((0, import_react.useEffect)(() => {
+    preloadedData && (loadedData[currentPath] = preloadedData, delete globalThis.__vxrnLoaderData__);
+  }, [preloadedData]), errors[currentPath])
+    throw errors[currentPath];
+  const loaded = loadedData[currentPath];
+  if (typeof loaded < "u")
+    return loaded;
+  if (!preloadedData) {
+    if (import_router.preloadingLoader[currentPath] && (typeof import_router.preloadingLoader[currentPath] == "function" && (import_router.preloadingLoader[currentPath] = import_router.preloadingLoader[currentPath]()), promises[currentPath] = import_router.preloadingLoader[currentPath].then((val) => {
+      loadedData[currentPath] = val;
+    }).catch((err) => {
+      console.error("Error loading loader", err), errors[currentPath] = err, delete promises[currentPath], delete import_router.preloadingLoader[currentPath];
+    })), !promises[currentPath]) {
+      const getData = async () => {
+        const loaderJSUrl = (0, import_cleanUrl.getLoaderPath)(currentPath, !0);
+        try {
+          const response = await (async () => {
+            if (isNative) {
+              const nativeLoaderJSUrl = `${loaderJSUrl}?platform=ios`;
+              try {
+                const loaderJsCodeResp = await fetch(nativeLoaderJSUrl);
+                if (!loaderJsCodeResp.ok)
+                  throw new Error(`Response not ok: ${loaderJsCodeResp.status}`);
+                const loaderJsCode = await loaderJsCodeResp.text(), result = eval(
+                  `() => { var exports = {}; ${loaderJsCode}; return exports; }`
+                )();
+                if (typeof result.loader != "function")
+                  throw new Error("Loader code isn't exporting a `loader` function");
+                return result;
+              } catch (e) {
+                return console.error(`Error fetching loader from URL: ${nativeLoaderJSUrl}, ${e}`), { loader: () => ({}) };
+              }
+            }
+            return await (0, import_dynamicImport.dynamicImport)(loaderJSUrl);
+          })();
+          return loadedData[currentPath] = response.loader(), loadedData[currentPath];
+        } catch (err) {
+          return console.error(`Error calling loader: ${err}`), errors[currentPath] = err, delete promises[currentPath], null;
+        }
+      };
+      promises[currentPath] = getData();
+    }
+    throw promises[currentPath];
+  }
+  return currentData.current;
+}
+const results = /* @__PURE__ */ new Map(), started = /* @__PURE__ */ new Map();
+function useAsyncFn(val, props) {
+  const key = (val ? (0, import_weakKey.weakKey)(val) : "") + JSON.stringify(props);
+  if (val && !started.get(key)) {
+    started.set(key, !0);
+    let next = val(props);
+    next instanceof Promise && (next = next.then((final) => {
+      results.set(key, final);
+    }).catch((err) => {
+      console.error("Error running loader()", err), results.set(key, void 0);
+    })), results.set(key, next);
+  }
+  const current = results.get(key);
+  if (current instanceof Promise)
+    throw current;
+  return current;
+}
+//# sourceMappingURL=useLoader.js.map

package/dist/cjs/useNavigation.js

@@ -0,0 +1,60 @@
+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 useNavigation_exports = {};
+__export(useNavigation_exports, {
+  resolveParentId: () => resolveParentId,
+  useNavigation: () => useNavigation
+});
+module.exports = __toCommonJS(useNavigation_exports);
+var import_native = require("@react-navigation/native"), import_react = __toESM(require("react"), 1), import_matchers = require("./matchers"), import_Route = require("./Route");
+function useNavigation(parent) {
+  const navigation = (0, import_native.useNavigation)(), contextKey = (0, import_Route.useContextKey)(), normalizedParent = import_react.default.useMemo(() => {
+    if (!parent)
+      return null;
+    const normalized = (0, import_matchers.getNameFromFilePath)(parent);
+    return parent.startsWith(".") ? relativePaths(contextKey, parent) : normalized;
+  }, [contextKey, parent]);
+  if (normalizedParent != null) {
+    const parentNavigation = navigation.getParent(normalizedParent);
+    if (!parentNavigation)
+      throw new Error(
+        `Could not find parent navigation with route "${parent}".` + (normalizedParent !== parent ? ` (normalized: ${normalizedParent})` : "")
+      );
+    return parentNavigation;
+  }
+  return navigation;
+}
+function resolveParentId(contextKey, parentId) {
+  return parentId ? parentId.startsWith(".") ? (0, import_matchers.getNameFromFilePath)(relativePaths(contextKey, parentId)) : (0, import_matchers.getNameFromFilePath)(parentId) : null;
+}
+function relativePaths(from, to) {
+  const fromParts = from.split("/").filter(Boolean), toParts = to.split("/").filter(Boolean);
+  for (const part of toParts)
+    if (part === "..") {
+      if (fromParts.length === 0)
+        throw new Error(`Cannot resolve path "${to}" relative to "${from}"`);
+      fromParts.pop();
+    } else part === "." || fromParts.push(part);
+  return "/" + fromParts.join("/");
+}
+//# sourceMappingURL=useNavigation.js.map