one 1.25.5 → 1.25.7

package/dist/cjs/createApp.native.js

@@ -0,0 +1,57 @@
+"use strict";
+
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), mod);
+var createApp_native_exports = {};
+__export(createApp_native_exports, {
+  createApp: () => createApp
+});
+module.exports = __toCommonJS(createApp_native_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react_native = require("react-native");
+var import_polyfills_mobile = require("./polyfills-mobile.native.js");
+var import_Root = require("./Root.native.js");
+var import_setup = require("./setup.native.js");
+import_react_native.LogBox.ignoreLogs([/Sending .* with no listeners registered/]);
+function createApp(options) {
+  var App = function () {
+    var contents = /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_Root.Root, {
+      isClient: true,
+      flags: options.flags,
+      routes: options.routes,
+      routerRoot: options.routerRoot,
+      linking: options.linking,
+      path: "/"
+    });
+    return contents;
+  };
+  import_react_native.AppRegistry.registerComponent("main", function () {
+    return App;
+  });
+  if (process.env.ONE_APP_NAME) {
+    import_react_native.AppRegistry.registerComponent(process.env.ONE_APP_NAME, function () {
+      return App;
+    });
+  }
+}
+//# sourceMappingURL=createApp.native.js.map

package/dist/cjs/createApp.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createApp_native_exports","__export","createApp","module","exports","__toCommonJS","import_jsx_runtime","require","import_react_native","import_polyfills_mobile","import_Root","import_setup","LogBox","ignoreLogs","options","App","contents","jsx","Root","isClient","flags","routes","routerRoot","linking","path","AppRegistry","registerComponent","process","env","ONE_APP_NAME"],"sources":["../../src/createApp.native.tsx"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,wBAAA;AAAAC,QAAA,CAAAD,wBAAA;EAAAE,SAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAC,YAAA,CAAAL,wBAAA;AAAA,IAAAM,kBAAA,GAA4BC,OAAA;AAC5B,IAAAC,mBAAA,GAAoCD,OAAA;AAEpC,IAAAE,uBAAA,GAAOF,OAAA;AACP,IAAAG,WAAA,GAAqBH,OAAA;AACrB,IAAAI,YAAA,GAAOJ,OAAA;AAEPC,mBAAA,CAAAI,MAAA,CAAOC,UAAA,CAAW,CACd,0CACH;AACM,SAASX,UAAUY,OAAA,EAAS;EAC/B,IAAIC,GAAA,GAAM,SAAAA,CAAA,EAAW;IACjB,IAAIC,QAAA,GAAyB,mBAAAV,kBAAA,CAAAW,GAAA,EAAKP,WAAA,CAAAQ,IAAA,EAAM;MACpCC,QAAA,EAAU;MACVC,KAAA,EAAON,OAAA,CAAQM,KAAA;MACfC,MAAA,EAAQP,OAAA,CAAQO,MAAA;MAChBC,UAAA,EAAYR,OAAA,CAAQQ,UAAA;MACpBC,OAAA,EAAST,OAAA,CAAQS,OAAA;MACjBC,IAAA,EAAM;IACV,CAAC;IACD,OAAOR,QAAA;EACX;EACAR,mBAAA,CAAAiB,WAAA,CAAYC,iBAAA,CAAkB,QAAQ,YAAW;IAC7C,OAAOX,GAAA;EACX,CAAC;EACD,IAAIY,OAAA,CAAQC,GAAA,CAAIC,YAAA,EAAc;IAC1BrB,mBAAA,CAAAiB,WAAA,CAAYC,iBAAA,CAAkBC,OAAA,CAAQC,GAAA,CAAIC,YAAA,EAAc,YAAW;MAC/D,OAAOd,GAAA;IACX,CAAC;EACL;AACJ","ignoreList":[]}

package/dist/cjs/createHandleRequest.cjs

@@ -0,0 +1,423 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), mod);
+var createHandleRequest_exports = {};
+__export(createHandleRequest_exports, {
+  compileManifest: () => compileManifest,
+  createHandleRequest: () => createHandleRequest,
+  getLoaderParams: () => getLoaderParams,
+  getSubdomain: () => getSubdomain,
+  getURLfromRequestURL: () => getURLfromRequestURL,
+  resolveAPIRoute: () => resolveAPIRoute,
+  resolveLoaderRoute: () => resolveLoaderRoute,
+  resolvePageRoute: () => resolvePageRoute,
+  runMiddlewares: () => runMiddlewares
+});
+module.exports = __toCommonJS(createHandleRequest_exports);
+var import_constants = require("./constants.cjs");
+var import_cleanUrl = require("./utils/cleanUrl.cjs");
+var import_isResponse = require("./utils/isResponse.cjs");
+var import_getManifest = require("./vite/getManifest.cjs");
+var import_resolveResponse = require("./vite/resolveResponse.cjs");
+const debugRouter = process.env.ONE_DEBUG_ROUTER;
+const staticAssetPathRe = /\.(?:[a-z0-9]{2,4}|webmanifest|wasm|woff2)$/i;
+function isStaticAssetRequestPath(pathname) {
+  return !pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED) && staticAssetPathRe.test(pathname);
+}
+function ensureResponse(value) {
+  if ((0, import_isResponse.isResponse)(value)) return value;
+  if (typeof value === "string") {
+    return new Response(value, {
+      headers: {
+        "Content-Type": "text/html"
+      }
+    });
+  }
+  if (value && typeof value === "object") {
+    return Response.json(value);
+  }
+  return new Response(value);
+}
+async function runMiddlewares(handlers, request, route, getResponse) {
+  const middlewares = route.middlewares;
+  if (!middlewares?.length) {
+    return await getResponse();
+  }
+  if (!handlers.loadMiddleware) {
+    throw new Error(`No middleware handler configured`);
+  }
+  if (debugRouter) {
+    console.info(`[one] \u{1F517} middleware chain (${middlewares.length}) for ${route.page}`);
+  }
+  const context = {};
+  async function dispatch(index) {
+    const middlewareModule = middlewares[index];
+    if (!middlewareModule) {
+      if (debugRouter) {
+        console.info(`[one] \u2713 middleware chain complete`);
+      }
+      return ensureResponse(await getResponse());
+    }
+    if (debugRouter) {
+      console.info(`[one]   \u2192 middleware[${index}]: ${middlewareModule.contextKey}`);
+    }
+    const exported = (await handlers.loadMiddleware(middlewareModule))?.default;
+    if (!exported) {
+      throw new Error(`No valid export found in middleware: ${middlewareModule.contextKey}`);
+    }
+    const next = async () => {
+      return dispatch(index + 1);
+    };
+    const response = await exported({
+      request,
+      next,
+      context
+    });
+    if (response) {
+      if (debugRouter) {
+        console.info(`[one]   \u2190 middleware[${index}] returned early (status: ${response.status})`);
+      }
+      return response;
+    }
+    return dispatch(index + 1);
+  }
+  return dispatch(0);
+}
+async function resolveAPIRoute(handlers, request, url, route, env, executionCtx) {
+  const {
+    pathname
+  } = url;
+  const params = getRouteParams(pathname, route);
+  if (debugRouter) {
+    console.info(`[one] \u{1F4E1} API ${request.method} ${pathname} \u2192 ${route.file}`, params);
+  }
+  return await runMiddlewares(handlers, request, route, async () => {
+    try {
+      return (0, import_resolveResponse.resolveAPIEndpoint)(() => handlers.handleAPI({
+        request,
+        route,
+        url,
+        loaderProps: {
+          path: pathname,
+          search: url.search,
+          subdomain: getSubdomain(url),
+          params
+        }
+      }), request, params || {}, env, executionCtx);
+    } catch (err) {
+      if ((0, import_isResponse.isResponse)(err)) {
+        return err;
+      }
+      if (process.env.NODE_ENV === "development") {
+        console.error(`
+ [one] Error importing API route at ${pathname}:
+
+          ${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.
+        `);
+      }
+      throw err;
+    }
+  });
+}
+async function resolveLoaderRoute(handlers, request, url, route) {
+  if (debugRouter) {
+    console.info(`[one] \u{1F4E6} loader ${url.pathname} \u2192 ${route.file}`);
+  }
+  const isNativeRequest = url.searchParams.get("platform") === "ios" || url.searchParams.get("platform") === "android";
+  const response = await runMiddlewares(handlers, request, route, async () => {
+    return await (0, import_resolveResponse.resolveResponse)(async () => {
+      const headers = new Headers();
+      headers.set("Content-Type", "text/javascript");
+      try {
+        const loaderResponse = await handlers.handleLoader({
+          request,
+          route,
+          url,
+          loaderProps: {
+            path: url.pathname,
+            search: url.search,
+            subdomain: getSubdomain(url),
+            request: route.type === "ssr" ? request : void 0,
+            params: getLoaderParams(url, route)
+          }
+        });
+        const body = isNativeRequest && loaderResponse ? toCjsLoader(loaderResponse) : loaderResponse;
+        return new Response(body, {
+          headers
+        });
+      } catch (err) {
+        if ((0, import_isResponse.isResponse)(err)) {
+          return err;
+        }
+        if (err?.code !== "ERR_MODULE_NOT_FOUND") {
+          console.error(`Error running loader: ${err}`);
+        }
+        throw err;
+      }
+    });
+  });
+  if (response.status >= 300 && response.status < 400) {
+    const location = response.headers.get("location");
+    if (location) {
+      const redirectUrl = new URL(location, url.origin);
+      const redirectPath = redirectUrl.pathname + redirectUrl.search + redirectUrl.hash;
+      const data = `{__oneRedirect:${JSON.stringify(redirectPath)},__oneRedirectStatus:${response.status}}`;
+      const body = isNativeRequest ? `exports.loader=function(){return ${data}}` : `export function loader(){return${data}}`;
+      return new Response(body, {
+        headers: {
+          "Content-Type": "text/javascript"
+        }
+      });
+    }
+  }
+  if (response.status === 401 || response.status === 403) {
+    const data = `{__oneError:${response.status},__oneErrorMessage:${JSON.stringify(response.statusText || "Unauthorized")}}`;
+    const body = isNativeRequest ? `exports.loader=function(){return ${data}}` : `export function loader(){return${data}}`;
+    return new Response(body, {
+      headers: {
+        "Content-Type": "text/javascript"
+      }
+    });
+  }
+  return response;
+}
+function toCjsLoader(esmCode) {
+  if (esmCode.startsWith("exports.")) {
+    return esmCode;
+  }
+  const match = esmCode.match(/export\s+function\s+loader\s*\(\)\s*\{\s*return\s+([\s\S]+)\s*\}/);
+  if (match) {
+    return `exports.loader=function(){return ${match[1]}}`;
+  }
+  return `exports.loader=function(){return {}}`;
+}
+async function resolvePageRoute(handlers, request, url, route) {
+  const {
+    pathname,
+    search
+  } = url;
+  if (debugRouter) {
+    console.info(`[one] \u{1F4C4} page ${pathname} \u2192 ${route.file} (${route.type})`);
+  }
+  const loaderProps = {
+    path: pathname,
+    search,
+    subdomain: getSubdomain(url),
+    request: route.type === "ssr" ? request : void 0,
+    params: getLoaderParams(url, route)
+  };
+  if (!route.middlewares?.length) {
+    return (0, import_resolveResponse.resolveResponse)(() => {
+      return handlers.handlePage({
+        request,
+        route,
+        url,
+        loaderProps
+      });
+    });
+  }
+  return (0, import_resolveResponse.resolveResponse)(async () => {
+    return await runMiddlewares(handlers, request, route, async () => {
+      return await handlers.handlePage({
+        request,
+        route,
+        url,
+        loaderProps
+      });
+    });
+  });
+}
+const _urlCache = /* @__PURE__ */new WeakMap();
+function getURLfromRequestURL(request) {
+  let url = _urlCache.get(request);
+  if (url) return url;
+  const urlString = request.url || "";
+  const host = request.headers.get("host");
+  url = new URL(urlString || "", host ? `http://${host}` : void 0);
+  _urlCache.set(request, url);
+  return url;
+}
+function getSubdomain(url) {
+  const host = url.hostname;
+  if (!host || host === "localhost" || /^\d+\.\d+\.\d+\.\d+$/.test(host)) {
+    return void 0;
+  }
+  const parts = host.split(".");
+  if (parts.length < 3) {
+    return void 0;
+  }
+  return parts.slice(0, -2).join(".");
+}
+function compileRouteRegex(route) {
+  return {
+    ...route,
+    compiledRegex: new RegExp(route.namedRegex)
+  };
+}
+function compileManifest(manifest) {
+  return {
+    pageRoutes: manifest.pageRoutes.map(compileRouteRegex),
+    apiRoutes: manifest.apiRoutes.map(compileRouteRegex)
+  };
+}
+function createHandleRequest(handlers, {
+  routerRoot,
+  ignoredRouteFiles,
+  routePaths
+}) {
+  const manifest = (0, import_getManifest.getManifest)({
+    routerRoot,
+    ignoredRouteFiles,
+    routePaths
+  });
+  if (!manifest) {
+    throw new Error(`No routes manifest`);
+  }
+  const compiledManifest = compileManifest(manifest);
+  return {
+    manifest,
+    handler: async function handleRequest(request) {
+      const url = getURLfromRequestURL(request);
+      const {
+        pathname,
+        search
+      } = url;
+      if (pathname === "/__vxrnhmr" || pathname.startsWith("/@vite/") || pathname.startsWith("/@fs/") || pathname.startsWith("/@id/") || pathname.startsWith("/node_modules/") || pathname.startsWith("/debugger-frontend") || pathname.startsWith("/inspector")) {
+        return null;
+      }
+      const looksLikeStaticFile = isStaticAssetRequestPath(pathname);
+      if (handlers.handleAPI) {
+        const apiRoute = compiledManifest.apiRoutes.find(route => {
+          return route.compiledRegex.test(pathname);
+        });
+        if (apiRoute) {
+          if (debugRouter) {
+            console.info(`[one] \u26A1 ${pathname} \u2192 matched API route: ${apiRoute.page}`);
+          }
+          return await resolveAPIRoute(handlers, request, url, apiRoute);
+        }
+      }
+      if (request.method !== "GET") {
+        return null;
+      }
+      if (handlers.handleLoader) {
+        const isClientRequestingNewRoute = pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED);
+        if (isClientRequestingNewRoute) {
+          const platformParam = url.searchParams.get("platform");
+          const isNativePlatform = platformParam === "ios" || platformParam === "android" || platformParam === "native";
+          if (isNativePlatform && handlers.handleStaticFile) {
+            const nativeLoaderPath = pathname.replace(/\.js$/, ".native.js");
+            const staticResponse = await handlers.handleStaticFile(nativeLoaderPath);
+            if (staticResponse) {
+              return staticResponse;
+            }
+          }
+          const originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(pathname);
+          for (const route of compiledManifest.pageRoutes) {
+            if (route.file === "") {
+              continue;
+            }
+            const finalUrl = new URL(originalUrl, url.origin);
+            finalUrl.search = url.search;
+            if (!route.compiledRegex.test(finalUrl.pathname)) {
+              continue;
+            }
+            if (route.hasLoader === false) {
+              const emptyBody2 = isNativePlatform ? "exports.loader=function(){return undefined}" : "export function loader() { return undefined }";
+              return new Response(emptyBody2, {
+                headers: {
+                  "Content-Type": "text/javascript"
+                }
+              });
+            }
+            const cleanedRequest = new Request(finalUrl, request);
+            return resolveLoaderRoute(handlers, cleanedRequest, finalUrl, route);
+          }
+          const emptyBody = isNativePlatform ? "exports.loader=function(){return{}}" : "export {}";
+          return new Response(emptyBody, {
+            headers: {
+              "Content-Type": "text/javascript"
+            }
+          });
+        }
+      }
+      if (handlers.handlePage) {
+        for (const route of compiledManifest.pageRoutes) {
+          if (!route.compiledRegex.test(pathname)) {
+            continue;
+          }
+          const isDynamicRoute = Object.keys(route.routeKeys).length > 0;
+          const isNotFoundRoute = route.page.endsWith("/+not-found");
+          if (looksLikeStaticFile && isNotFoundRoute) {
+            if (debugRouter) {
+              console.info(`[one] \u26A1 ${pathname} \u2192 bare 404 for static probe on ${route.page}`);
+            }
+            if (!route.middlewares?.length) {
+              return null;
+            }
+            return await runMiddlewares(handlers, request, route, async () => {
+              return new Response(null, {
+                status: 404,
+                headers: {
+                  "Content-Type": "text/plain"
+                }
+              });
+            });
+          }
+          if (looksLikeStaticFile && isDynamicRoute) {
+            if (debugRouter) {
+              console.info(`[one] \u26A1 ${pathname} \u2192 skipping dynamic route ${route.page} for static asset`);
+            }
+            continue;
+          }
+          if (debugRouter) {
+            console.info(`[one] \u26A1 ${pathname} \u2192 matched page route: ${route.page} (${route.type})`);
+          }
+          return resolvePageRoute(handlers, request, url, route);
+        }
+      }
+      return null;
+    }
+  };
+}
+function getLoaderParams(url, config) {
+  const params = {};
+  const match = config.compiledRegex.exec(url.pathname);
+  if (match?.groups) {
+    for (const [key, value] of Object.entries(match.groups)) {
+      const namedKey = config.routeKeys[key];
+      params[namedKey] = value;
+    }
+  }
+  return params;
+}
+function getRouteParams(pathname, route) {
+  const regex = new RegExp(route.namedRegex);
+  const match = regex.exec(pathname);
+  if (!match) return {};
+  return Object.fromEntries(Object.entries(route.routeKeys).map(([key, value]) => {
+    return [value, match.groups?.[key] || ""];
+  }));
+}