@absolutejs/absolute 0.19.0-beta.1115 → 0.19.0-beta.1117

package/dist/react/jsxDevRuntimeCompat.js

@@ -3,7 +3,6 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
@@ -30,23 +29,6 @@ var __toESM = (mod, isNodeMode, target) => {
     cache.set(mod, to);
   return to;
 };
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -86,5 +68,5 @@ export {
   Fragment
 };
 
-//# debugId=D6695015FE3A1E9264756E2164756E21
+//# debugId=EB16DE1F5202CABA64756E2164756E21
 //# sourceMappingURL=jsxDevRuntimeCompat.js.map

package/dist/react/jsxDevRuntimeCompat.js.map

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import { Fragment, jsx, jsxs } from 'react/jsx-runtime';\n\ntype JSXType = Parameters<typeof jsx>[0];\ntype JSXKey = Parameters<typeof jsx>[2];\ntype JSXProps = Parameters<typeof jsx>[1] & {\n\tchildren?: unknown;\n};\n\nexport { Fragment };\n\nexport const jsxDEV = (\n\ttype: JSXType,\n\tprops: JSXProps,\n\tkey?: JSXKey,\n\t_isStaticChildren?: boolean,\n\t_source?: unknown,\n\t_self?: unknown\n) =>\n\tArray.isArray(props?.children)\n\t\t? jsxs(type, props, key)\n\t\t: jsx(type, props, key);\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAUO,IAAM,SAAS,CACrB,MACA,OACA,KACA,mBACA,SACA,UAEA,MAAM,QAAQ,OAAO,QAAQ,IAC1B,KAAK,MAAM,OAAO,GAAG,IACrB,IAAI,MAAM,OAAO,GAAG;",
-  "debugId": "D6695015FE3A1E9264756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAUO,IAAM,SAAS,CACrB,MACA,OACA,KACA,mBACA,SACA,UAEA,MAAM,QAAQ,OAAO,QAAQ,IAC1B,KAAK,MAAM,OAAO,GAAG,IACrB,IAAI,MAAM,OAAO,GAAG;",
+  "debugId": "EB16DE1F5202CABA64756E2164756E21",
   "names": []
 }

package/dist/react/router/browser.js

@@ -3,7 +3,6 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
@@ -30,23 +29,6 @@ var __toESM = (mod, isNodeMode, target) => {
     cache.set(mod, to);
   return to;
 };
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -91,5 +73,5 @@ export {
   UniversalRouter
 };
 
-//# debugId=9785C1C2D083082064756E2164756E21
+//# debugId=83C2A10A433A92F464756E2164756E21
 //# sourceMappingURL=browser.js.map

package/dist/react/router/browser.js.map

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import { createElement, type ReactNode } from 'react';\nimport { BrowserRouter, StaticRouter } from 'react-router';\n\nexport type UniversalRouterProps = {\n\t/** The request URL to seed `<StaticRouter>` with on the server. Pages\n\t *  typically forward `props.url` (auto-injected by handleReactPageRequest\n\t *  from `request.url`). Ignored in the browser, where `<BrowserRouter>`\n\t *  reads `window.location` directly. Defaults to '/'. */\n\turl?: string;\n\tchildren?: ReactNode;\n};\n\n/** SSR-safe wrapper around react-router that picks `<StaticRouter>` on the\n *  server and `<BrowserRouter>` in the browser. Without it, every SPA page\n *  has to write its own `typeof window === 'undefined'` branch and import\n *  both routers — boilerplate that's the same in every page.\n *\n *  Usage:\n *\n *    import { UniversalRouter } from '@absolutejs/absolute/react/router';\n *\n *    export const MySpa = ({ url }: { url?: string }) => (\n *      <html>\n *        <Head />\n *        <body>\n *          <UniversalRouter url={url}>\n *            <Routes>\n *              <Route path=\"/foo\" element={<Foo />} />\n *            </Routes>\n *          </UniversalRouter>\n *        </body>\n *      </html>\n *    );\n *\n *  This component lives on its own `@absolutejs/absolute/react/router`\n *  subpath rather than the main `@absolutejs/absolute/react` barrel so the\n *  static `import 'react-router'` below only loads for consumers who\n *  actually use the router — importing `Head`/`Image`/`Island` from\n *  `@absolutejs/absolute/react` does not pull react-router into the bundle,\n *  so projects that don't route aren't forced to install it.\n *\n *  `<BrowserRouter>` reads `window.history` at construction, so it throws\n *  if instantiated on the server. The `typeof window` check has to live at\n *  render time (not import time) because the module is loaded in both\n *  environments. */\nexport const UniversalRouter = ({ url, children }: UniversalRouterProps) => {\n\tif (typeof window === 'undefined') {\n\t\treturn createElement(StaticRouter, { location: url ?? '/' }, children);\n\t}\n\n\treturn createElement(BrowserRouter, null, children);\n};\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AA4CO,IAAM,kBAAkB,GAAG,KAAK,eAAqC;AAAA,EAC3E,IAAI,OAAO,WAAW,aAAa;AAAA,IAClC,OAAO,cAAc,cAAc,EAAE,UAAU,OAAO,IAAI,GAAG,QAAQ;AAAA,EACtE;AAAA,EAEA,OAAO,cAAc,eAAe,MAAM,QAAQ;AAAA;",
-  "debugId": "9785C1C2D083082064756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AA4CO,IAAM,kBAAkB,GAAG,KAAK,eAAqC;AAAA,EAC3E,IAAI,OAAO,WAAW,aAAa;AAAA,IAClC,OAAO,cAAc,cAAc,EAAE,UAAU,OAAO,IAAI,GAAG,QAAQ;AAAA,EACtE;AAAA,EAEA,OAAO,cAAc,eAAe,MAAM,QAAQ;AAAA;",
+  "debugId": "83C2A10A433A92F464756E2164756E21",
   "names": []
 }

package/dist/react/router/index.js

@@ -3,7 +3,6 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
@@ -30,23 +29,6 @@ var __toESM = (mod, isNodeMode, target) => {
     cache.set(mod, to);
   return to;
 };
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -91,5 +73,5 @@ export {
   UniversalRouter
 };
 
-//# debugId=C66D8416C656662B64756E2164756E21
+//# debugId=72E041D68FC9B52864756E2164756E21
 //# sourceMappingURL=index.js.map

package/dist/react/router/index.js.map

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import { createElement, type ReactNode } from 'react';\nimport { BrowserRouter, StaticRouter } from 'react-router';\n\nexport type UniversalRouterProps = {\n\t/** The request URL to seed `<StaticRouter>` with on the server. Pages\n\t *  typically forward `props.url` (auto-injected by handleReactPageRequest\n\t *  from `request.url`). Ignored in the browser, where `<BrowserRouter>`\n\t *  reads `window.location` directly. Defaults to '/'. */\n\turl?: string;\n\tchildren?: ReactNode;\n};\n\n/** SSR-safe wrapper around react-router that picks `<StaticRouter>` on the\n *  server and `<BrowserRouter>` in the browser. Without it, every SPA page\n *  has to write its own `typeof window === 'undefined'` branch and import\n *  both routers — boilerplate that's the same in every page.\n *\n *  Usage:\n *\n *    import { UniversalRouter } from '@absolutejs/absolute/react/router';\n *\n *    export const MySpa = ({ url }: { url?: string }) => (\n *      <html>\n *        <Head />\n *        <body>\n *          <UniversalRouter url={url}>\n *            <Routes>\n *              <Route path=\"/foo\" element={<Foo />} />\n *            </Routes>\n *          </UniversalRouter>\n *        </body>\n *      </html>\n *    );\n *\n *  This component lives on its own `@absolutejs/absolute/react/router`\n *  subpath rather than the main `@absolutejs/absolute/react` barrel so the\n *  static `import 'react-router'` below only loads for consumers who\n *  actually use the router — importing `Head`/`Image`/`Island` from\n *  `@absolutejs/absolute/react` does not pull react-router into the bundle,\n *  so projects that don't route aren't forced to install it.\n *\n *  `<BrowserRouter>` reads `window.history` at construction, so it throws\n *  if instantiated on the server. The `typeof window` check has to live at\n *  render time (not import time) because the module is loaded in both\n *  environments. */\nexport const UniversalRouter = ({ url, children }: UniversalRouterProps) => {\n\tif (typeof window === 'undefined') {\n\t\treturn createElement(StaticRouter, { location: url ?? '/' }, children);\n\t}\n\n\treturn createElement(BrowserRouter, null, children);\n};\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AA4CO,IAAM,kBAAkB,GAAG,KAAK,eAAqC;AAAA,EAC3E,IAAI,OAAO,WAAW,aAAa;AAAA,IAClC,OAAO,cAAc,cAAc,EAAE,UAAU,OAAO,IAAI,GAAG,QAAQ;AAAA,EACtE;AAAA,EAEA,OAAO,cAAc,eAAe,MAAM,QAAQ;AAAA;",
-  "debugId": "C66D8416C656662B64756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AA4CO,IAAM,kBAAkB,GAAG,KAAK,eAAqC;AAAA,EAC3E,IAAI,OAAO,WAAW,aAAa;AAAA,IAClC,OAAO,cAAc,cAAc,EAAE,UAAU,OAAO,IAAI,GAAG,QAAQ;AAAA,EACtE;AAAA,EAEA,OAAO,cAAc,eAAe,MAAM,QAAQ;AAAA;",
+  "debugId": "72E041D68FC9B52864756E2164756E21",
   "names": []
 }

package/dist/react/server.js

@@ -3,7 +3,6 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
@@ -30,23 +29,6 @@ var __toESM = (mod, isNodeMode, target) => {
     cache.set(mod, to);
   return to;
 };
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -88,22 +70,20 @@ __export(exports_devRouteRegistrationCallsite, {
 });
 import { AsyncLocalStorage } from "async_hooks";
 import { Elysia } from "elysia";
-var ROUTE_CALLSITE_STORAGE_KEY, ROUTE_CALLSITE_PATCHED_KEY, ROUTE_METHOD_NAMES, PAGE_HANDLER_NAMES, pageHandlerWrappers, handlerSourceMentionsPageHelper = (handler) => {
+var ROUTE_CALLSITE_STORAGE_KEY, ROUTE_CALLSITE_PATCHED_KEY, ROUTE_METHOD_NAMES, PAGE_HANDLER_NAMES, pageHandlerWrappers, isPageHandlerFunction = (value) => typeof value === "function", handlerSourceMentionsPageHelper = (handler) => {
   const source = handler.toString();
   return PAGE_HANDLER_NAMES.some((name) => source.includes(name));
 }, getOriginalPageHandlerSource = (handler) => {
-  if (typeof handler !== "function")
+  if (!isPageHandlerFunction(handler))
     return;
-  const fn = handler;
-  const info = pageHandlerWrappers.get(fn);
-  return (info?.originalHandler ?? fn).toString();
+  const info = pageHandlerWrappers.get(handler);
+  return (info?.originalHandler ?? handler).toString();
 }, isPageHandler = (handler) => {
-  if (typeof handler !== "function")
+  if (!isPageHandlerFunction(handler))
     return false;
-  const fn = handler;
-  if (pageHandlerWrappers.has(fn))
+  if (pageHandlerWrappers.has(handler))
     return true;
-  return handlerSourceMentionsPageHelper(fn);
+  return handlerSourceMentionsPageHelper(handler);
 }, isObjectRecord3 = (value) => Boolean(value) && typeof value === "object", isAsyncLocalStorage2 = (value) => isObjectRecord3(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function", isRouteMethod = (value) => typeof value === "function", getRouteCallsiteStorage = () => {
   const value = Reflect.get(globalThis, ROUTE_CALLSITE_STORAGE_KEY);
   if (value === null || typeof value === "undefined") {
@@ -140,7 +120,7 @@ var ROUTE_CALLSITE_STORAGE_KEY, ROUTE_CALLSITE_PATCHED_KEY, ROUTE_METHOD_NAMES,
 }, createPatchedRouteMethod = (originalMethod, methodName) => function patchedRouteMethod(path, handler, ...rest) {
   const callsite = captureRouteRegistrationCallsite();
   const wrapped = wrapRouteHandlerWithCallsite(handler, callsite);
-  if (methodName === "get" && typeof handler === "function" && typeof wrapped === "function" && handlerSourceMentionsPageHelper(handler)) {
+  if (methodName === "get" && isPageHandlerFunction(handler) && isPageHandlerFunction(wrapped) && handlerSourceMentionsPageHelper(handler)) {
     pageHandlerWrappers.set(wrapped, {
       originalHandler: handler
     });
@@ -1168,8 +1148,8 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
 }, isDev = () => true, buildErrorProps = (error) => {
   if (error instanceof Error) {
     return {
-      name: error.name,
       message: error.message,
+      name: error.name,
       ...isDev() && error.stack ? { stack: error.stack } : {}
     };
   }
@@ -1253,7 +1233,7 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
   let conventionPath = resolveErrorConventionPath(framework, pageName);
   if (!conventionPath && error instanceof Error && error.stack) {
     for (const match of error.stack.matchAll(/^\s*at\s+([A-Za-z_$][\w$]*)/gm)) {
-      const candidate = match[1];
+      const [, candidate] = match;
       if (!candidate)
         continue;
       conventionPath = resolveErrorConventionPath(framework, candidate);
@@ -1401,9 +1381,9 @@ var init_resolveConvention = __esm(() => {
 import { basename as basename2 } from "path";
 var SPA_ROUTES_KEY = "__absoluteSpaRoutes", setSpaRouteManifest = (hosts) => {
   Reflect.set(globalThis, SPA_ROUTES_KEY, hosts);
-}, getSpaRouteManifest = () => {
+}, isRuntimeSpaHost = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "framework") === "string", getSpaRouteManifest = () => {
   const value = Reflect.get(globalThis, SPA_ROUTES_KEY);
-  return Array.isArray(value) ? value : [];
+  return Array.isArray(value) ? value.filter(isRuntimeSpaHost) : [];
 }, normalizePath = (path) => {
   const withLeadingSlash = path.startsWith("/") ? path : `/${path}`;
   const trimmed = withLeadingSlash.replace(/\/+$/, "");
@@ -1910,6 +1890,7 @@ var runWithStreamingSlotWarningScope = (task, metadata) => ensureWarningStorage(
 // src/react/pageHandler.ts
 init_spaRouteManifest();
 init_resolveConvention();
+var withRequestUrl = (props, url) => Object.assign(Object.create(null), props, { url });
 var resolveRequestPathname = (request) => {
   if (!request)
     return;
@@ -1930,10 +1911,7 @@ var handleReactPageRequest = async (input) => {
   const options = input;
   const userProps = input.props;
   const requestPathname = resolveRequestPathname(input.request);
-  const maybeProps = requestPathname !== undefined && (!userProps || !("url" in userProps)) ? {
-    ...userProps ?? {},
-    url: requestPathname
-  } : userProps;
+  const maybeProps = requestPathname !== undefined && (!userProps || !("url" in userProps)) ? withRequestUrl(userProps, requestPathname) : userProps;
   const pageName = Page.name || Page.displayName || "";
   try {
     const spaNotFound = await renderSpaNotFound("react", pageName, input.request);
@@ -1984,5 +1962,5 @@ export {
   handleReactPageRequest
 };
 
-//# debugId=C6A90A3BEC2CC84964756E2164756E21
+//# debugId=685C0C4025F0697E64756E2164756E21
 //# sourceMappingURL=server.js.map