@absolutejs/absolute 0.20.0-beta.4 → 0.20.0-beta.41

package/dist/vue/server.js

@@ -829,7 +829,7 @@ var SLOT_ID_PREFIX = "abs-slot-", CLOSING_BODY_TAG = "</body>", CLOSING_HEAD_TAG
     getStreamingSlotsRuntimeScript()
   ].filter(Boolean).join(";");
   return `<script${createNonceAttr(nonce)}>${escapeScriptContent(runtimeBody)}</script>`;
-}, toUint8 = (value, encoder) => encoder.encode(value), isRecord = (value) => Boolean(value) && typeof value === "object", isSafeHtmlLike = (value) => isRecord(value) && typeof value.changingThisBreaksApplicationSecurity === "string", normalizeSafeHtml = (value) => {
+}, toUint8 = (value, encoder) => encoder.encode(value), isRecord2 = (value) => Boolean(value) && typeof value === "object", isSafeHtmlLike = (value) => isRecord2(value) && typeof value.changingThisBreaksApplicationSecurity === "string", normalizeSafeHtml = (value) => {
   if (isSafeHtmlLike(value)) {
     return value.changingThisBreaksApplicationSecurity;
   }
@@ -890,7 +890,7 @@ var SLOT_ID_PREFIX = "abs-slot-", CLOSING_BODY_TAG = "</body>", CLOSING_HEAD_TAG
 }, createTimeoutError = (slot, timeoutMs) => {
   const error = Object.assign(new Error(`Streaming slot "${slot.id}" timed out after ${timeoutMs}ms`), { __absTimeout: true });
   return error;
-}, isSlotPatchPayloadObject = (value) => isRecord(value) && ("html" in value), isTimeoutError = (error) => isRecord(error) && error.__absTimeout === true, toStreamingSlot = (slot, policy) => ({
+}, isSlotPatchPayloadObject = (value) => isRecord2(value) && ("html" in value), isTimeoutError = (error) => isRecord2(error) && error.__absTimeout === true, toStreamingSlot = (slot, policy) => ({
   errorHtml: slot.errorHtml === undefined ? policy.errorHtml : slot.errorHtml,
   fallbackHtml: normalizeSlotText(slot.fallbackHtml, policy.fallbackHtml),
   id: slot.id ?? createStreamingSlotId(),
@@ -1402,6 +1402,7 @@ var colors, MONTHS, formatTimestamp = () => {
     port,
     host,
     networkUrl,
+    mobilePreviewUrl,
     protocol = "http"
   } = options;
   const name = `${colors.cyan}${colors.bold}ABSOLUTEJS${colors.reset}`;
@@ -1415,6 +1416,9 @@ var colors, MONTHS, formatTimestamp = () => {
   if (networkUrl) {
     console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Network:${colors.reset} ${networkUrl}`);
   }
+  if (mobilePreviewUrl) {
+    console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Mobile:${colors.reset}  ${mobilePreviewUrl}`);
+  }
   console.log("");
 };
 var init_startupBanner = __esm(() => {
@@ -2039,6 +2043,278 @@ var setCurrentIslandManifest = (manifest) => {
 
 // src/vue/pageHandler.ts
 init_devRouteRegistrationCallsite();
+
+// src/core/requestContext.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import { Elysia as Elysia2 } from "elysia";
+var REQUEST_STORAGE_KEY = Symbol.for("absolutejs.requestAsyncLocalStorage");
+var isAbsoluteRequestStorage = (value) => typeof value === "object" && value !== null && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";
+var getRequestStorage = () => {
+  const value = Reflect.get(globalThis, REQUEST_STORAGE_KEY);
+  return isAbsoluteRequestStorage(value) ? value : undefined;
+};
+var ensureRequestStorage = () => {
+  const existing = getRequestStorage();
+  if (existing)
+    return existing;
+  const storage = new AsyncLocalStorage2;
+  Reflect.set(globalThis, REQUEST_STORAGE_KEY, storage);
+  return storage;
+};
+var absoluteRequestContext = new Elysia2({
+  name: "absolutejs-request-context"
+}).request(({ request }) => {
+  ensureRequestStorage().enterWith({ request });
+}).as("global");
+var getCurrentAbsoluteRequest = () => getRequestStorage()?.getStore()?.request;
+var runWithAbsoluteRequest = (request, callback) => ensureRequestStorage().run({ request }, callback);
+
+// src/mobile/producerContextState.ts
+var ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY = Symbol.for("absolutejs.mobileProducerAsyncLocalStorage");
+var frameworks = new Set([
+  "angular",
+  "ember",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var isCompatibilityPage = (value) => typeof value === "object" && value !== null && ("bundleHash" in value) && typeof value.bundleHash === "string" && ("contract" in value) && typeof value.contract === "string" && ("framework" in value) && typeof value.framework === "string" && frameworks.has(value.framework) && ("pageId" in value) && typeof value.pageId === "string" && ("propsSchemaHash" in value) && typeof value.propsSchemaHash === "string";
+var getCurrentAbsoluteMobileProducerContext = () => {
+  const value = Reflect.get(globalThis, ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY);
+  if (typeof value !== "object" || value === null || !("getStore" in value) || typeof value.getStore !== "function") {
+    return;
+  }
+  const context = value.getStore();
+  if (typeof context !== "object" || context === null || !("page" in context) || !isCompatibilityPage(context.page) || !("releaseId" in context) || typeof context.releaseId !== "string") {
+    return;
+  }
+  return { page: context.page, releaseId: context.releaseId };
+};
+
+// src/mobile/pageProtocol.ts
+var ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE = "application/vnd.absolute.page+json";
+var ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION = 1;
+var BAD_REQUEST_STATUS = 400;
+var OK_STATUS = 200;
+var SERVER_ERROR_STATUS = 500;
+var UPGRADE_REQUIRED_STATUS = 426;
+var MOBILE_PAGE_REQUEST_HEADERS = {
+  appBuild: "x-absolute-mobile-app-build",
+  pageBundle: "x-absolute-mobile-page-bundle",
+  pageContracts: "x-absolute-mobile-page-contracts",
+  pageId: "x-absolute-mobile-page-id",
+  protocol: "x-absolute-mobile-protocol",
+  runtime: "x-absolute-mobile-runtime"
+};
+var parseMediaType = (value) => value.split(";", 1)[0]?.trim().toLowerCase();
+var acceptsAbsoluteMobilePage = (request) => {
+  if (!request)
+    return false;
+  return (request.headers.get("accept") ?? "").split(",").some((value) => parseMediaType(value) === ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE);
+};
+var readRequiredHeader = (request, name) => {
+  const value = request.headers.get(name)?.trim();
+  return value ? value : undefined;
+};
+var parseAbsoluteMobilePageRequest = (request) => {
+  if (!request || !acceptsAbsoluteMobilePage(request)) {
+    return { kind: "not-mobile" };
+  }
+  const protocolValue = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.protocol);
+  const runtime = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.runtime);
+  const appBuild = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.appBuild);
+  const pageBundle = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageBundle);
+  const pageContractsValue = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageContracts);
+  const pageId = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageId);
+  if (!protocolValue || !/^\d+$/.test(protocolValue)) {
+    return {
+      kind: "invalid",
+      message: `Missing or invalid ${MOBILE_PAGE_REQUEST_HEADERS.protocol} header.`
+    };
+  }
+  if (!runtime) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.runtime} header.`
+    };
+  }
+  if (!appBuild) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.appBuild} header.`
+    };
+  }
+  if (!pageBundle) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageBundle} header.`
+    };
+  }
+  if (!pageContractsValue) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageContracts} header.`
+    };
+  }
+  if (!pageId) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageId} header.`
+    };
+  }
+  const pageContracts = [
+    ...new Set(pageContractsValue.split(",").map((value) => value.trim()).filter(Boolean))
+  ];
+  if (pageContracts.length === 0) {
+    return {
+      kind: "invalid",
+      message: `${MOBILE_PAGE_REQUEST_HEADERS.pageContracts} must contain at least one contract.`
+    };
+  }
+  return {
+    client: {
+      appBuild,
+      pageBundle,
+      pageContracts,
+      pageId,
+      protocol: Number(protocolValue),
+      runtime
+    },
+    kind: "mobile"
+  };
+};
+var responseHeaders = () => {
+  const headers = new Headers({
+    "cache-control": "no-store",
+    "content-type": `${ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE}; version=${ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION}`
+  });
+  headerVaryValues.forEach((value) => headers.append("vary", value));
+  return headers;
+};
+var headerVaryValues = [
+  "Accept",
+  MOBILE_PAGE_REQUEST_HEADERS.protocol,
+  MOBILE_PAGE_REQUEST_HEADERS.runtime,
+  MOBILE_PAGE_REQUEST_HEADERS.appBuild,
+  MOBILE_PAGE_REQUEST_HEADERS.pageBundle,
+  MOBILE_PAGE_REQUEST_HEADERS.pageContracts,
+  MOBILE_PAGE_REQUEST_HEADERS.pageId
+];
+var envelopeResponse = (response, status) => new Response(JSON.stringify({
+  protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
+  response
+}), { headers: responseHeaders(), status });
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeJsonValue = (value) => {
+  const serialized = JSON.stringify(value);
+  if (serialized === undefined) {
+    throw new TypeError("Mobile page props must be JSON-serializable.");
+  }
+  const parsed = JSON.parse(serialized);
+  if (!isRecord(parsed)) {
+    throw new TypeError("Mobile page props must serialize to an object.");
+  }
+  return parsed;
+};
+var finalizeArchivedMobilePage = (context, input) => {
+  const { page } = context;
+  if (page.pageId !== input.compatibility.pageId || page.framework !== input.compatibility.framework) {
+    return envelopeResponse({
+      kind: "invalid-request",
+      message: "Archived producer page identity does not match its release artifact."
+    }, BAD_REQUEST_STATUS);
+  }
+  try {
+    const [currentRepresentation] = input.compatibility.representations;
+    if (!currentRepresentation) {
+      throw new TypeError("Mobile page has no current representation.");
+    }
+    return envelopeResponse({
+      contract: page.contract,
+      framework: page.framework,
+      kind: "page",
+      pageId: page.pageId,
+      props: normalizeJsonValue(currentRepresentation.mapProps(input.props)),
+      status: input.status ?? OK_STATUS
+    }, input.status ?? OK_STATUS);
+  } catch (error) {
+    console.error(`[Mobile] Archived producer ${context.releaseId} failed for ${page.pageId}:`, error);
+    return createAbsoluteMobilePageErrorResponse(page.pageId);
+  }
+};
+var createAbsoluteMobileInvalidRequestResponse = (message) => envelopeResponse({ kind: "invalid-request", message }, BAD_REQUEST_STATUS);
+var createAbsoluteMobilePageErrorResponse = (pageId) => envelopeResponse({
+  code: "representation-failed",
+  kind: "error",
+  pageId,
+  status: SERVER_ERROR_STATUS
+}, SERVER_ERROR_STATUS);
+var createAbsoluteMobileUpgradeResponse = (result) => envelopeResponse(result, UPGRADE_REQUIRED_STATUS);
+var finalizeAbsoluteMobilePage = (input) => {
+  const parsed = parseAbsoluteMobilePageRequest(input.request);
+  if (parsed.kind === "not-mobile")
+    return;
+  if (parsed.kind === "invalid") {
+    return envelopeResponse({ kind: "invalid-request", message: parsed.message }, BAD_REQUEST_STATUS);
+  }
+  const { client } = parsed;
+  if (client.pageId !== input.compatibility.pageId) {
+    return envelopeResponse({
+      kind: "invalid-request",
+      message: `Requested mobile page ${client.pageId} does not match ${input.compatibility.pageId}.`
+    }, BAD_REQUEST_STATUS);
+  }
+  const producerContext = getCurrentAbsoluteMobileProducerContext();
+  if (producerContext)
+    return finalizeArchivedMobilePage(producerContext, input);
+  if (client.protocol !== ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION) {
+    return envelopeResponse({
+      kind: "upgrade-required",
+      pageId: input.compatibility.pageId,
+      reason: "protocol"
+    }, UPGRADE_REQUIRED_STATUS);
+  }
+  if (!input.compatibility.runtimes.includes(client.runtime)) {
+    return envelopeResponse({
+      kind: "upgrade-required",
+      pageId: input.compatibility.pageId,
+      reason: "runtime",
+      supportedRuntimes: [...input.compatibility.runtimes]
+    }, UPGRADE_REQUIRED_STATUS);
+  }
+  const clientContracts = new Set(client.pageContracts);
+  const representation = input.compatibility.representations.find(({ contract }) => clientContracts.has(contract));
+  if (!representation) {
+    return envelopeResponse({
+      kind: "upgrade-required",
+      pageId: input.compatibility.pageId,
+      reason: "page-contract",
+      supportedContracts: input.compatibility.representations.map(({ contract }) => contract)
+    }, UPGRADE_REQUIRED_STATUS);
+  }
+  try {
+    return envelopeResponse({
+      contract: representation.contract,
+      framework: input.compatibility.framework,
+      kind: "page",
+      pageId: input.compatibility.pageId,
+      props: normalizeJsonValue(representation.mapProps(input.props)),
+      status: input.status ?? OK_STATUS
+    }, input.status ?? OK_STATUS);
+  } catch (error) {
+    console.error(`[Mobile] Failed to produce ${input.compatibility.pageId} representation ${representation.contract}:`, error);
+    return envelopeResponse({
+      code: "representation-failed",
+      kind: "error",
+      pageId: input.compatibility.pageId,
+      status: SERVER_ERROR_STATUS
+    }, SERVER_ERROR_STATUS);
+  }
+};
+
+// src/vue/pageHandler.ts
 init_pageResponseCache();
 
 // src/core/responseEnhancers.ts
@@ -2095,7 +2371,7 @@ var withRegisteredStreamingSlots = async (renderResponse, options = {}) => {
 
 // src/core/streamingSlotWarningScope.ts
 init_logger();
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 var STREAMING_SLOT_WARNING_STORAGE_KEY2 = Symbol.for("absolutejs.streamingSlotWarningAsyncLocalStorage");
 var isObjectRecord4 = (value) => Boolean(value) && typeof value === "object";
 var isAsyncLocalStorage3 = (value) => isObjectRecord4(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";
@@ -2111,7 +2387,7 @@ var ensureWarningStorage = () => {
   if (existing) {
     return existing;
   }
-  const storage = new AsyncLocalStorage2;
+  const storage = new AsyncLocalStorage3;
   Reflect.set(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY2, storage);
   return storage;
 };
@@ -2193,23 +2469,23 @@ var ABSOLUTE_TELEPORT_TARGET_ID = "absolute-teleports";
 var ABSOLUTE_TELEPORT_TARGET = `#${ABSOLUTE_TELEPORT_TARGET_ID}`;
 
 // src/vue/pageHandler.ts
-var isRecord2 = (value) => typeof value === "object" && value !== null;
-var isGenericVueComponent = (value) => typeof value === "function" || isRecord2(value);
+var isRecord3 = (value) => typeof value === "object" && value !== null;
+var isGenericVueComponent = (value) => typeof value === "function" || isRecord3(value);
 var readHasIslands = (value) => {
-  if (!isRecord2(value))
+  if (!isRecord3(value))
     return false;
   const hasIslands = value["__ABSOLUTE_PAGE_HAS_ISLANDS__"];
   return typeof hasIslands === "boolean" ? hasIslands : false;
 };
 var isVueSetupApp = (value) => typeof value === "function";
 var readSetupAppHook = (value) => {
-  if (!isRecord2(value))
+  if (!isRecord3(value))
     return null;
   const { setupApp } = value;
   return isVueSetupApp(setupApp) ? setupApp : null;
 };
-var readHasSpaRoutes = (value) => isRecord2(value) && Array.isArray(value["routes"]);
-var readDefaultExport = (value) => isRecord2(value) ? value.default : undefined;
+var readHasSpaRoutes = (value) => isRecord3(value) && Array.isArray(value["routes"]);
+var readDefaultExport = (value) => isRecord3(value) ? value.default : undefined;
 var resolveRequestRenderUrl = (request) => {
   if (!request)
     return "/";
@@ -2239,12 +2515,29 @@ var getSsrOnlyHmrShim = () => {
 };
 var handleVuePageRequest = async (input) => {
   const passedPageComponent = input.Page;
+  const request = input.request ?? getCurrentAbsoluteRequest();
+  const pageId = input.__absoluteMobile?.pageId ?? derivePageName(input.pagePath);
+  const currentContract = input.__absoluteMobile?.contract ?? `vue:${pageId}:${ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION}`;
+  const mobileResponse = finalizeAbsoluteMobilePage({
+    compatibility: {
+      framework: "vue",
+      pageId,
+      representations: [
+        { contract: currentContract, mapProps: (props) => props }
+      ],
+      runtimes: [String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)]
+    },
+    props: input.props ?? Object.create(null),
+    request
+  });
+  if (mobileResponse)
+    return mobileResponse;
   const userHeadTag = input.headTag ?? "<head></head>";
   const resolvedOptions = input;
   const resolvedPagePath = input.pagePath;
   const [siblingCss, spaChildCss] = await Promise.all([
     readSiblingCss(resolvedPagePath),
-    resolveSpaChildCss(resolvedPagePath, input.request?.url)
+    resolveSpaChildCss(resolvedPagePath, request?.url)
   ]);
   const resolvedHeadTag = injectInlineCss(injectInlineCss(userHeadTag, siblingCss), spaChildCss);
   const maybeProps = input.props;
@@ -2257,9 +2550,9 @@ var handleVuePageRequest = async (input) => {
     throw new Error('handleVuePageRequest: `indexPath` is required when `client` is `"auto"` (the default). Pass `client: "none"` to ship a SSR-only page with no client bundle.');
   }
   try {
-    const spaNotFound = await renderSpaNotFound("vue", derivePageName(resolvedPagePath), input.request);
+    const spaNotFound = await renderSpaNotFound("vue", derivePageName(resolvedPagePath), request);
     if (spaNotFound)
-      return withPageCacheHeaders(spaNotFound, input.request);
+      return withPageCacheHeaders(spaNotFound, request);
     const handlerCallsite = resolvedOptions?.collectStreamingSlots === true ? undefined : getCurrentRouteRegistrationCallsite() ?? captureStreamingSlotWarningCallsite();
     const renderPageResponse = async () => {
       const resolvePageComponent = async () => {
@@ -2292,7 +2585,7 @@ var handleVuePageRequest = async (input) => {
       let pendingRedirect = null;
       let pendingNotFound = false;
       if (resolvedPage.setupApp) {
-        const url = resolveRequestRenderUrl(input.request);
+        const url = resolveRequestRenderUrl(request);
         await resolvedPage.setupApp(app, {
           isServer: true,
           router: null,
@@ -2373,7 +2666,7 @@ var handleVuePageRequest = async (input) => {
       });
     };
     const pageResponse = await runWithStreamingSlotWarningScope(() => resolvedOptions?.collectStreamingSlots === true ? withRegisteredStreamingSlots(renderPageResponse, resolvedOptions) : renderPageResponse(), { handlerCallsite });
-    return withPageCacheHeaders(pageResponse, input.request, {
+    return withPageCacheHeaders(pageResponse, request, {
       bufferStreamForEtag: input.bufferStreamForEtag
     });
   } catch (error) {
@@ -2381,12 +2674,12 @@ var handleVuePageRequest = async (input) => {
     const pageName = derivePageName(resolvedPagePath);
     const conventionResponse = await renderConventionError("vue", pageName, error);
     if (conventionResponse) {
-      return withPageCacheHeaders(conventionResponse, input.request);
+      return withPageCacheHeaders(conventionResponse, request);
     }
     return withPageCacheHeaders(new Response(ssrErrorPage("vue", error), {
       headers: { "Content-Type": "text/html" },
       status: 500
-    }), input.request);
+    }), request);
   }
 };
 // src/vue/routerRedirectProviders.ts
@@ -2411,5 +2704,5 @@ export {
   applyVueRouterRedirect
 };
 
-//# debugId=89D724EF33B3354364756E2164756E21
+//# debugId=91AD96587D4ADBF264756E2164756E21
 //# sourceMappingURL=server.js.map