one 1.1.319 → 1.1.321

package/dist/cjs/fork/useLinking.js

@@ -0,0 +1,182 @@
+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 useLinking_exports = {};
+__export(useLinking_exports, {
+  default: () => useLinking,
+  series: () => series
+});
+module.exports = __toCommonJS(useLinking_exports);
+var import_core = require("@react-navigation/core"), import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1), React = __toESM(require("react"), 1), import_createMemoryHistory = __toESM(require("./createMemoryHistory"), 1), import_serverLocationContext = require("../router/serverLocationContext"), import_getPathFromState = require("./getPathFromState");
+const historyGlobal = (0, import_createMemoryHistory.default)();
+typeof window < "u" && historyGlobal.listen(() => {
+  globalThis.__vxrntodopath = window.location.pathname;
+});
+const findMatchingState = (a, b) => {
+  if (a === void 0 || b === void 0 || a.key !== b.key)
+    return [void 0, void 0];
+  const aHistoryLength = a.history ? a.history.length : a.routes.length, bHistoryLength = b.history ? b.history.length : b.routes.length, aRoute = a.routes[a.index], bRoute = b.routes[b.index], aChildState = aRoute.state, bChildState = bRoute.state;
+  return aHistoryLength !== bHistoryLength || aRoute.key !== bRoute.key || aChildState === void 0 || bChildState === void 0 || aChildState.key !== bChildState.key ? [a, b] : findMatchingState(aChildState, bChildState);
+}, series = (cb) => {
+  let queue = Promise.resolve();
+  return () => {
+    queue = queue.then(cb);
+  };
+};
+let linkingHandlers = [];
+function useLinking(ref, {
+  independent,
+  enabled = !0,
+  config,
+  getStateFromPath = import_core.getStateFromPath,
+  getPathFromState = import_core.getPathFromState,
+  getActionFromState = import_core.getActionFromState
+}) {
+  React.useEffect(() => {
+    if (process.env.NODE_ENV === "production" || independent)
+      return;
+    enabled !== !1 && linkingHandlers.length && console.error(
+      [
+        "Looks like you have configured linking in multiple places. This is likely an error since deep links should only be handled in one place to avoid conflicts. Make sure that:",
+        "- You don't have multiple NavigationContainers in the app each with 'linking' enabled",
+        "- Only a single instance of the root component is rendered"
+      ].join(`
+`).trim()
+    );
+    const handler = Symbol();
+    return enabled !== !1 && linkingHandlers.push(handler), () => {
+      const index = linkingHandlers.indexOf(handler);
+      index > -1 && linkingHandlers.splice(index, 1);
+    };
+  }, [enabled, independent]);
+  const [history] = React.useState(historyGlobal), enabledRef = React.useRef(enabled), configRef = React.useRef(config), getStateFromPathRef = React.useRef(getStateFromPath), getPathFromStateRef = React.useRef(getPathFromState), getActionFromStateRef = React.useRef(getActionFromState);
+  React.useEffect(() => {
+    enabledRef.current = enabled, configRef.current = config, getStateFromPathRef.current = getStateFromPath, getPathFromStateRef.current = getPathFromState, getActionFromStateRef.current = getActionFromState;
+  });
+  const server = { location: React.useContext(import_serverLocationContext.ServerLocationContext) }, getInitialState = React.useCallback(() => {
+    let value;
+    if (enabledRef.current) {
+      const location2 = server?.location ?? (typeof window < "u" ? window.location : void 0), path = location2 ? location2.pathname + location2.search : void 0;
+      path && (value = getStateFromPathRef.current(path, configRef.current));
+    }
+    const thenable = {
+      // biome-ignore lint/suspicious/noThenProperty: <explanation>
+      then(onfulfilled) {
+        return Promise.resolve(onfulfilled ? onfulfilled(value) : value);
+      },
+      catch() {
+        return thenable;
+      }
+    };
+    return thenable;
+  }, []), previousIndexRef = React.useRef(void 0), previousStateRef = React.useRef(void 0), pendingPopStatePathRef = React.useRef(void 0);
+  return React.useEffect(() => (previousIndexRef.current = history.index, history.listen(() => {
+    const navigation = ref.current;
+    if (!navigation || !enabled)
+      return;
+    const { location: location2 } = window, path = location2.pathname + location2.search, index = history.index, previousIndex = previousIndexRef.current ?? 0;
+    previousIndexRef.current = index, pendingPopStatePathRef.current = path;
+    const record = history.get(index);
+    if (record?.path === path && record?.state) {
+      navigation.resetRoot(record.state);
+      return;
+    }
+    const state = getStateFromPathRef.current(path, configRef.current);
+    if (state) {
+      const rootState = navigation.getRootState();
+      if (state.routes.some((r) => !rootState?.routeNames.includes(r.name))) {
+        console.warn(
+          "The navigation state parsed from the URL contains routes not present in the root navigator. This usually means that the linking configuration doesn't match the navigation structure. See https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration."
+        );
+        return;
+      }
+      if (index > previousIndex) {
+        const action = getActionFromStateRef.current(state, configRef.current);
+        if (action !== void 0)
+          try {
+            navigation.dispatch(action);
+          } catch (e) {
+            console.warn(
+              `An error occurred when trying to handle the link '${path}': ${typeof e == "object" && e != null && "message" in e ? e.message : e}`
+            );
+          }
+        else
+          navigation.resetRoot(state);
+      } else
+        navigation.resetRoot(state);
+    } else
+      navigation.resetRoot(state);
+  })), [enabled, history, ref]), React.useEffect(() => {
+    if (!enabled)
+      return;
+    const getPathForRoute = (route, state) => {
+      if (route?.path) {
+        const stateForPath = getStateFromPathRef.current(route.path, configRef.current);
+        if (stateForPath) {
+          const focusedRoute = (0, import_core.findFocusedRoute)(stateForPath);
+          if (focusedRoute && focusedRoute.name === route.name && (0, import_fast_deep_equal.default)(focusedRoute.params, route.params))
+            return (0, import_getPathFromState.appendBaseUrl)(route.path);
+        }
+      }
+      return getPathFromStateRef.current(state, configRef.current);
+    };
+    if (ref.current) {
+      const state = ref.current.getRootState();
+      if (state) {
+        const route = (0, import_core.findFocusedRoute)(state), path = getPathForRoute(route, state);
+        previousStateRef.current === void 0 && (previousStateRef.current = state), history.replace({ path, state });
+      }
+    }
+    const onStateChange = async () => {
+      const navigation = ref.current;
+      if (!navigation || !enabled)
+        return;
+      const previousState = previousStateRef.current, state = navigation.getRootState();
+      if (!state)
+        return;
+      const pendingPath = pendingPopStatePathRef.current, route = (0, import_core.findFocusedRoute)(state), path = getPathForRoute(route, state);
+      previousStateRef.current = state, pendingPopStatePathRef.current = void 0;
+      const [previousFocusedState, focusedState] = findMatchingState(previousState, state);
+      if (previousFocusedState && focusedState && // We should only handle push/pop if path changed from what was in last `popstate`
+      // Otherwise it's likely a change triggered by `popstate`
+      path !== pendingPath) {
+        const historyDelta = (focusedState.history ? focusedState.history.length : focusedState.routes.length) - (previousFocusedState.history ? previousFocusedState.history.length : previousFocusedState.routes.length);
+        if (historyDelta > 0)
+          history.push({ path, state });
+        else if (historyDelta < 0) {
+          const nextIndex = history.backIndex({ path }), currentIndex = history.index;
+          try {
+            nextIndex !== -1 && nextIndex < currentIndex && // We should only go back if the entry exists and it's less than current index
+            history.get(nextIndex - currentIndex) ? await history.go(nextIndex - currentIndex) : await history.go(historyDelta), history.replace({ path, state });
+          } catch {
+          }
+        } else
+          history.replace({ path, state });
+      } else
+        history.replace({ path, state });
+    };
+    return ref.current?.addListener("state", series(onStateChange));
+  }, [enabled, history, ref]), {
+    getInitialState
+  };
+}
+//# sourceMappingURL=useLinking.js.map

package/dist/cjs/fork/validatePathConfig.js

@@ -0,0 +1,46 @@
+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 validatePathConfig_exports = {};
+__export(validatePathConfig_exports, {
+  default: () => validatePathConfig
+});
+module.exports = __toCommonJS(validatePathConfig_exports);
+const formatToList = (items) => items.map((key) => `- ${key}`).join(`
+`);
+function validatePathConfig(config, root = !0) {
+  const validKeys = ["initialRouteName", "screens", "_route"];
+  root || validKeys.push("path", "exact", "stringify", "parse");
+  const invalidKeys = Object.keys(config).filter((key) => !validKeys.includes(key));
+  if (invalidKeys.length)
+    throw new Error(
+      `Found invalid properties in the configuration:
+${formatToList(
+        invalidKeys
+      )}
+
+Did you forget to specify them under a 'screens' property?
+
+You can only specify the following properties:
+${formatToList(
+        validKeys
+      )}
+
+See https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration.`
+    );
+  config.screens && Object.entries(config.screens).forEach(([_, value]) => {
+    typeof value != "string" && validatePathConfig(value, !1);
+  });
+}
+//# sourceMappingURL=validatePathConfig.js.map

package/dist/cjs/getLinkingConfig.js

@@ -0,0 +1,59 @@
+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 getLinkingConfig_exports = {};
+__export(getLinkingConfig_exports, {
+  getLinkingConfig: () => getLinkingConfig,
+  getNavigationConfig: () => getNavigationConfig,
+  stateCache: () => stateCache
+});
+module.exports = __toCommonJS(getLinkingConfig_exports);
+var import_native = require("@react-navigation/native"), import_getReactNavigationConfig = require("./getReactNavigationConfig"), import_linking = require("./link/linking");
+function getNavigationConfig(routes, metaOnly = !0) {
+  return (0, import_getReactNavigationConfig.getReactNavigationConfig)(routes, metaOnly);
+}
+function getLinkingConfig(routes, metaOnly = !0) {
+  return {
+    prefixes: [],
+    // @ts-expect-error
+    config: getNavigationConfig(routes, metaOnly),
+    // A custom getInitialURL is used on native to ensure the app always starts at
+    // the root path if it's launched from something other than a deep link.
+    // This helps keep the native functionality working like the web functionality.
+    // For example, if you had a root navigator where the first screen was `/settings` and the second was `/index`
+    // then `/index` would be used on web and `/settings` would be used on native.
+    getInitialURL: import_linking.getInitialURL,
+    subscribe: import_linking.addEventListener,
+    getStateFromPath: getStateFromPathMemoized,
+    getPathFromState(state, options) {
+      return (0, import_linking.getPathFromState)(state, {
+        screens: [],
+        ...this.config,
+        ...options
+      }) ?? "/";
+    },
+    // Add all functions to ensure the types never need to fallback.
+    // This is a convenience for usage in the package.
+    getActionFromState: import_native.getActionFromState
+  };
+}
+const stateCache = /* @__PURE__ */ new Map();
+function getStateFromPathMemoized(path, options) {
+  const cached = stateCache.get(path);
+  if (cached)
+    return cached;
+  const result = (0, import_linking.getStateFromPath)(path, options);
+  return stateCache.set(path, result), result;
+}
+//# sourceMappingURL=getLinkingConfig.js.map

package/dist/cjs/getReactNavigationConfig.js

@@ -0,0 +1,69 @@
+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 getReactNavigationConfig_exports = {};
+__export(getReactNavigationConfig_exports, {
+  getReactNavigationConfig: () => getReactNavigationConfig,
+  getReactNavigationScreensConfig: () => getReactNavigationScreensConfig
+});
+module.exports = __toCommonJS(getReactNavigationConfig_exports);
+var import_matchers = require("./matchers");
+function convertDynamicRouteToReactNavigation(segment) {
+  if (segment === "index")
+    return "";
+  const rest = (0, import_matchers.matchDeepDynamicRouteName)(segment);
+  if (rest != null)
+    return "*" + rest;
+  const dynamicName = (0, import_matchers.matchDynamicName)(segment);
+  return dynamicName != null ? `:${dynamicName}` : segment;
+}
+function parseRouteSegments(segments) {
+  return (
+    // NOTE: When there are nested routes without layouts
+    // the node.route will be something like `app/home/index`
+    // this needs to be split to ensure each segment is parsed correctly.
+    segments.split("/").map(convertDynamicRouteToReactNavigation).filter(Boolean).join("/")
+  );
+}
+function convertRouteNodeToScreen(node, metaOnly) {
+  const path = parseRouteSegments(node.route);
+  if (!node.children.length)
+    return metaOnly ? path : {
+      path,
+      screens: {},
+      _route: node
+    };
+  const screens = getReactNavigationScreensConfig(node.children, metaOnly), screen = {
+    path,
+    screens,
+    // NOTE: This is bad because it forces all Layout Routes
+    // to be loaded into memory. We should move towards a system where
+    // the initial route name is either loaded asynchronously in the Layout Route
+    // or defined via a file system convention.
+    initialRouteName: node.initialRouteName
+  };
+  return metaOnly || (screen._route = node), screen;
+}
+function getReactNavigationScreensConfig(nodes, metaOnly) {
+  return Object.fromEntries(
+    nodes.map((node) => [node.route, convertRouteNodeToScreen(node, metaOnly)])
+  );
+}
+function getReactNavigationConfig(routes, metaOnly) {
+  return {
+    initialRouteName: routes.initialRouteName,
+    screens: getReactNavigationScreensConfig(routes.children, metaOnly)
+  };
+}
+//# sourceMappingURL=getReactNavigationConfig.js.map

package/dist/cjs/getRoutes.js

@@ -0,0 +1,294 @@
+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 getRoutes_exports = {};
+__export(getRoutes_exports, {
+  extrapolateGroups: () => extrapolateGroups,
+  generateDynamic: () => generateDynamic,
+  getExactRoutes: () => getExactRoutes,
+  getIgnoreList: () => getIgnoreList,
+  getRoutes: () => getRoutes
+});
+module.exports = __toCommonJS(getRoutes_exports);
+var import_config = require("./config"), import_matchers = require("./matchers"), import_getPageExport = require("./utils/getPageExport");
+const validPlatforms = /* @__PURE__ */ new Set(["android", "ios", "native", "web"]);
+function getRoutes(contextModule, options = {}) {
+  const directoryTree = getDirectoryTree(contextModule, options);
+  if (!directoryTree)
+    return null;
+  const rootNode = flattenDirectoryTreeToRoutes(directoryTree, options);
+  return options.ignoreEntryPoints || crawlAndAppendInitialRoutesAndEntryFiles(rootNode, options), rootNode;
+}
+function getExactRoutes(contextModule, options = {}) {
+  return getRoutes(contextModule, {
+    ...options,
+    skipGenerated: !0
+  });
+}
+function getDirectoryTree(contextModule, options) {
+  const importMode = options.importMode || process.env.One_ROUTER_IMPORT_MODE, ignoreList = [/^\.\/\+html\.[tj]sx?$/];
+  options.ignore && ignoreList.push(...options.ignore), options.preserveApiRoutes || ignoreList.push(/\+api\.[tj]sx?$/);
+  const rootDirectory = {
+    files: /* @__PURE__ */ new Map(),
+    subdirectories: /* @__PURE__ */ new Map()
+  };
+  let hasRoutes = !1, isValid = !1;
+  for (const filePath of contextModule.keys()) {
+    if (ignoreList.some((regex) => regex.test(filePath)))
+      continue;
+    isValid = !0;
+    const meta = getFileMeta(filePath, options);
+    if (meta.specificity < 0)
+      continue;
+    const type = meta.isLayout ? "layout" : meta.renderMode || (0, import_config.getDefaultRenderMode)();
+    let node = {
+      type,
+      loadRoute() {
+        if (options.ignoreRequireErrors)
+          try {
+            return contextModule(filePath);
+          } catch {
+            return {};
+          }
+        else
+          return contextModule(filePath);
+      },
+      contextKey: filePath,
+      route: "",
+      // This is overwritten during hoisting based upon the _layout
+      dynamic: null,
+      children: []
+      // While we are building the directory tree, we don't know the node's children just yet. This is added during hoisting
+    };
+    if (!(process.env.NODE_ENV === "development" && node.type !== "api" && importMode === "sync" && !(0, import_getPageExport.getPageExport)(node.loadRoute())))
+      for (const route of extrapolateGroups(meta.route)) {
+        const subdirectoryParts = route.split("/").slice(0, -1);
+        let directory = rootDirectory;
+        for (const part of subdirectoryParts) {
+          let subDirectory = directory.subdirectories.get(part);
+          subDirectory || (subDirectory = {
+            files: /* @__PURE__ */ new Map(),
+            subdirectories: /* @__PURE__ */ new Map()
+          }, directory.subdirectories.set(part, subDirectory)), directory = subDirectory;
+        }
+        if (node = { ...node, route }, meta.isLayout) {
+          directory.layout ??= [];
+          const existing = directory.layout[meta.specificity];
+          if (existing) {
+            if (process.env.NODE_ENV !== "production")
+              throw new Error(
+                `The layouts "${filePath}" and "${existing.contextKey}" conflict on the route "/${route}". Please remove or rename one of these files.`
+              );
+          } else
+            node = getLayoutNode(node, options), directory.layout[meta.specificity] = node;
+        } else if (type === "api") {
+          const fileKey = `${route}+api`;
+          let nodes = directory.files.get(fileKey);
+          nodes || (nodes = [], directory.files.set(fileKey, nodes));
+          const existing = nodes[0];
+          if (existing) {
+            if (process.env.NODE_ENV !== "production")
+              throw new Error(
+                `The API route file "${filePath}" and "${existing.contextKey}" conflict on the route "/${route}". Please remove or rename one of these files.`
+              );
+          } else
+            nodes[0] = node;
+        } else {
+          let nodes = directory.files.get(route);
+          nodes || (nodes = [], directory.files.set(route, nodes));
+          const existing = nodes[meta.specificity];
+          if (existing) {
+            if (process.env.NODE_ENV !== "production")
+              throw new Error(
+                `The route files "${filePath}" and "${existing.contextKey}" conflict on the route "/${route}". Please remove or rename one of these files.`
+              );
+          } else
+            hasRoutes ||= !0, nodes[meta.specificity] = node;
+        }
+      }
+  }
+  return isValid ? (rootDirectory.layout || (rootDirectory.layout = [
+    {
+      type: "layout",
+      loadRoute: () => ({
+        default: require("./views/Navigator").DefaultNavigator
+      }),
+      // Generate a fake file name for the directory
+      contextKey: "router/build/views/Navigator.js",
+      route: "",
+      generated: !0,
+      dynamic: null,
+      children: []
+    }
+  ]), options.skipGenerated || (hasRoutes && appendSitemapRoute(rootDirectory), appendNotFoundRoute(rootDirectory)), rootDirectory) : null;
+}
+function flattenDirectoryTreeToRoutes(directory, options, layout, pathToRemove = "") {
+  if (directory.layout) {
+    const previousLayout = layout;
+    layout = getMostSpecific(directory.layout), previousLayout && previousLayout.children.push(layout), options.internal_stripLoadRoute && delete layout.loadRoute;
+    const newRoute = layout.route.replace(pathToRemove, "");
+    pathToRemove = layout.route ? `${layout.route}/` : "", layout.route = newRoute, layout.dynamic = generateDynamic(layout.route);
+  }
+  if (!layout) throw new Error("One Internal Error: No nearest layout");
+  for (const routes of directory.files.values()) {
+    const routeNode = getMostSpecific(routes);
+    routeNode.route = routeNode.route.replace(pathToRemove, ""), routeNode.dynamic = generateDynamic(routeNode.route), options.internal_stripLoadRoute && delete routeNode.loadRoute, layout.children.push(routeNode);
+  }
+  for (const child of directory.subdirectories.values())
+    flattenDirectoryTreeToRoutes(child, options, layout, pathToRemove);
+  return layout;
+}
+function getFileMeta(key, options) {
+  key = key.replace(/^\.\//, "");
+  const parts = key.split("/");
+  let route = (0, import_matchers.removeSupportedExtensions)(key);
+  const filename = parts[parts.length - 1], filenameWithoutExtensions = (0, import_matchers.removeSupportedExtensions)(filename), isLayout = filenameWithoutExtensions.startsWith("_layout"), [_fullname, renderModeFound] = filename.match(/\+(api|ssg|ssr|spa)\.(\w+\.)?[jt]sx?$/) || [], renderMode = renderModeFound;
+  if (filenameWithoutExtensions.startsWith("(") && filenameWithoutExtensions.endsWith(")"))
+    throw new Error(`Invalid route ./${key}. Routes cannot end with '(group)' syntax`);
+  if (renderMode !== "api" && filename.startsWith("+") && filenameWithoutExtensions !== "+not-found") {
+    const renamedRoute = [...parts.slice(0, -1), filename.slice(1)].join("/");
+    throw new Error(
+      `Invalid route ./${key}. Route nodes cannot start with the '+' character. "Please rename to ${renamedRoute}"`
+    );
+  }
+  let specificity = 0;
+  const platformExtension = filenameWithoutExtensions.split(".")[1], hasPlatformExtension = validPlatforms.has(platformExtension), usePlatformRoutes = options.platformRoutes ?? !0;
+  if (hasPlatformExtension) {
+    if (usePlatformRoutes && options.platform ? platformExtension === options.platform ? specificity = 2 : platformExtension === "native" && options.platform !== "web" ? specificity = 1 : platformExtension !== options.platform && (specificity = -1) : specificity = -1, renderMode === "api" && specificity !== 0)
+      throw new Error(
+        `Api routes cannot have platform extensions. Please remove '.${platformExtension}' from './${key}'`
+      );
+    route = route.replace(new RegExp(`.${platformExtension}$`), "");
+  }
+  return {
+    route,
+    specificity,
+    isLayout,
+    renderMode
+  };
+}
+function getMostSpecific(routes) {
+  const route = routes[routes.length - 1];
+  if (!routes[0])
+    throw new Error(
+      ` [one] The file ${route.contextKey} does not have a fallback sibling file without a platform extension in routes (${routes[0]}, ${routes.length}):
+${routes.map((r) => r.contextKey || "NONE").join(`
+`)}.`
+    );
+  return routes[routes.length - 1];
+}
+function getIgnoreList(options) {
+  const ignore = [/^\.\/\+html\.[tj]sx?$/, ...options?.ignore ?? []];
+  return options?.preserveApiRoutes !== !0 && ignore.push(/\+api\.[tj]sx?$/), ignore;
+}
+function extrapolateGroups(key, keys = /* @__PURE__ */ new Set()) {
+  const match = (0, import_matchers.matchArrayGroupName)(key);
+  if (!match)
+    return keys.add(key), keys;
+  const groups = match.split(",");
+  if (new Set(groups).size !== groups.length)
+    throw new Error(`Array syntax cannot contain duplicate group name "${groups}" in "${key}".`);
+  if (groups.length === 1)
+    return keys.add(key), keys;
+  for (const group of groups)
+    extrapolateGroups(key.replace(match, group.trim()), keys);
+  return keys;
+}
+function generateDynamic(path) {
+  const dynamic = path.split("/").map((part) => {
+    if (part === "+not-found")
+      return {
+        name: "+not-found",
+        deep: !0,
+        notFound: !0
+      };
+    const deepDynamicName = (0, import_matchers.matchDeepDynamicRouteName)(part), dynamicName = deepDynamicName ?? (0, import_matchers.matchDynamicName)(part);
+    return dynamicName ? { name: dynamicName, deep: !!deepDynamicName } : null;
+  }).filter((part) => !!part);
+  return dynamic.length === 0 ? null : dynamic;
+}
+function appendSitemapRoute(directory) {
+  directory.files.has("_sitemap") || directory.files.set("_sitemap", [
+    {
+      loadRoute() {
+        return { default: () => null, getNavOptions: () => {
+        } };
+      },
+      route: "_sitemap",
+      type: "ssg",
+      contextKey: "",
+      generated: !0,
+      internal: !0,
+      dynamic: null,
+      children: []
+    }
+  ]);
+}
+function appendNotFoundRoute(directory) {
+  directory.files.has("+not-found") || directory.files.set("+not-found", [
+    {
+      loadRoute() {
+        return { default: () => null };
+      },
+      type: "spa",
+      route: "+not-found",
+      contextKey: "",
+      generated: !0,
+      internal: !0,
+      dynamic: [{ name: "+not-found", deep: !0, notFound: !0 }],
+      children: []
+    }
+  ]);
+}
+function getLayoutNode(node, options) {
+  const groupName = (0, import_matchers.matchGroupName)(node.route);
+  let initialRouteName = node.children.find((child) => child.route.replace(/\/index$/, "") === groupName)?.route;
+  return {
+    ...node,
+    route: node.route.replace(/\/?_layout$/, ""),
+    children: [],
+    // Each layout should have its own children
+    initialRouteName
+  };
+}
+function crawlAndAppendInitialRoutesAndEntryFiles(node, options, entryPoints = []) {
+  if (node.type === "spa" || node.type === "ssg" || node.type === "ssr")
+    node.entryPoints = [.../* @__PURE__ */ new Set([...entryPoints, node.contextKey])];
+  else if (node.type === "layout") {
+    if (!node.children)
+      throw new Error(`Layout "${node.contextKey}" does not contain any child routes`);
+    entryPoints = [...entryPoints, node.contextKey];
+    const groupName = (0, import_matchers.matchGroupName)(node.route);
+    let initialRouteName = node.children.find((child) => child.route.replace(/\/index$/, "") === groupName)?.route;
+    if (!options.internal_stripLoadRoute) {
+      const loaded = node.loadRoute();
+      loaded?.unstable_settings && (initialRouteName = loaded.unstable_settings.initialRouteName ?? initialRouteName, groupName && (initialRouteName = loaded.unstable_settings?.[groupName]?.initialRouteName ?? initialRouteName));
+    }
+    if (initialRouteName) {
+      const initialRoute = node.children.find((child) => child.route === initialRouteName);
+      if (!initialRoute) {
+        const validInitialRoutes = node.children.filter((child) => !child.generated).map((child) => `'${child.route}'`).join(", ");
+        throw groupName ? new Error(
+          `Layout ${node.contextKey} has invalid initialRouteName '${initialRouteName}' for group '(${groupName})'. Valid options are: ${validInitialRoutes}`
+        ) : new Error(
+          `Layout ${node.contextKey} has invalid initialRouteName '${initialRouteName}'. Valid options are: ${validInitialRoutes}`
+        );
+      }
+      node.initialRouteName = initialRouteName, entryPoints.push(initialRoute.contextKey);
+    }
+    for (const child of node.children)
+      crawlAndAppendInitialRoutesAndEntryFiles(child, options, entryPoints);
+  }
+}
+//# sourceMappingURL=getRoutes.js.map

package/dist/cjs/getURL.js

@@ -0,0 +1,24 @@
+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 getURL_exports = {};
+__export(getURL_exports, {
+  getURL: () => getURL
+});
+module.exports = __toCommonJS(getURL_exports);
+const CLIENT_BASE_URL = typeof window < "u" && window.location ? `${window.location.protocol}//${window.location.host}` : "";
+function getURL() {
+  return CLIENT_BASE_URL || process.env.ONE_SERVER_URL || "http://localhost";
+}
+//# sourceMappingURL=getURL.js.map