@absolutejs/absolute 0.20.0-beta.6 → 0.20.0-beta.61

package/dist/mobile/browser.js

@@ -19,12 +19,14 @@ var __toESM = (mod, isNodeMode, target) => {
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -87,6 +89,7 @@ var getCurrentAbsoluteMobileProducerContext = () => {
 // src/mobile/pageProtocol.ts
 var ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE = "application/vnd.absolute.page+json";
 var ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION = 1;
+var ABSOLUTE_NATIVE_ROUTE_DATA_MEDIA_TYPE = "application/vnd.absolute.native-route+json";
 var BAD_REQUEST_STATUS = 400;
 var OK_STATUS = 200;
 var SERVER_ERROR_STATUS = 500;
@@ -105,6 +108,11 @@ var acceptsAbsoluteMobilePage = (request) => {
     return false;
   return (request.headers.get("accept") ?? "").split(",").some((value) => parseMediaType(value) === ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE);
 };
+var acceptsAbsoluteNativeRouteData = (request) => {
+  if (!request)
+    return false;
+  return (request.headers.get("accept") ?? "").split(",").some((value) => parseMediaType(value) === ABSOLUTE_NATIVE_ROUTE_DATA_MEDIA_TYPE);
+};
 var readRequiredHeader = (request, name) => {
   const value = request.headers.get(name)?.trim();
   return value ? value : undefined;
@@ -235,6 +243,32 @@ var finalizeArchivedMobilePage = (context, input) => {
     return createAbsoluteMobilePageErrorResponse(page.pageId);
   }
 };
+var finalizeAbsoluteNativeRouteDevelopmentPage = (input) => {
+  if (false) {}
+  if (input.request?.method !== "GET") {
+    return createAbsoluteMobileInvalidRequestResponse("Native-route data requests must use GET.");
+  }
+  if (input.request.headers.get(MOBILE_PAGE_REQUEST_HEADERS.protocol) !== String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)) {
+    return createAbsoluteMobileInvalidRequestResponse(`Native-route data requires protocol ${ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION}.`);
+  }
+  const [representation] = input.compatibility.representations;
+  if (!representation) {
+    return createAbsoluteMobilePageErrorResponse(input.compatibility.pageId);
+  }
+  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 development native route ${input.compatibility.pageId}:`, error);
+    return createAbsoluteMobilePageErrorResponse(input.compatibility.pageId);
+  }
+};
 var createAbsoluteMobileInvalidRequestResponse = (message) => envelopeResponse({ kind: "invalid-request", message }, BAD_REQUEST_STATUS);
 var createAbsoluteMobilePageErrorResponse = (pageId) => envelopeResponse({
   code: "representation-failed",
@@ -244,6 +278,9 @@ var createAbsoluteMobilePageErrorResponse = (pageId) => envelopeResponse({
 }, SERVER_ERROR_STATUS);
 var createAbsoluteMobileUpgradeResponse = (result) => envelopeResponse(result, UPGRADE_REQUIRED_STATUS);
 var finalizeAbsoluteMobilePage = (input) => {
+  if (acceptsAbsoluteNativeRouteData(input.request)) {
+    return finalizeAbsoluteNativeRouteDevelopmentPage(input);
+  }
   const parsed = parseAbsoluteMobilePageRequest(input.request);
   if (parsed.kind === "not-mobile")
     return;
@@ -307,7 +344,6 @@ var finalizeAbsoluteMobilePage = (input) => {
 
 // src/mobile/client.ts
 class AbsoluteMobilePageProtocolError extends Error {
-  code;
   constructor(code, message) {
     super(message);
     this.name = "AbsoluteMobilePageProtocolError";
@@ -421,21 +457,394 @@ var parseAbsoluteMobilePageEnvelope = (value) => {
   }
   throw new AbsoluteMobilePageProtocolError("invalid-envelope", `Unknown mobile page response kind ${String(kind)}.`);
 };
+// node_modules/@absolutejs/sync/dist/client/runtimeTransport.js
+var RUNTIME_TRANSPORT = Symbol.for("@absolutejs/sync/client-runtime-transport");
+var host = globalThis;
+var isRegistry = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations")) && Array.isArray(Reflect.get(value, "clients"));
+var registry = (() => {
+  const existing = host[RUNTIME_TRANSPORT];
+  if (isRegistry(existing))
+    return existing;
+  if (typeof existing === "object" && existing !== null && Array.isArray(Reflect.get(existing, "installations"))) {
+    Reflect.set(existing, "clients", []);
+    return existing;
+  }
+  const created = { clients: [], installations: [] };
+  Object.defineProperty(host, RUNTIME_TRANSPORT, {
+    configurable: false,
+    enumerable: false,
+    value: created,
+    writable: false
+  });
+  return created;
+})();
+var maximum = (values) => {
+  const present = values.filter((value) => value !== undefined);
+  return present.length === 0 ? undefined : Math.max(...present);
+};
+var minimum = (values) => {
+  const present = values.filter((value) => value !== undefined);
+  return present.length === 0 ? undefined : Math.min(...present);
+};
+var inspectSyncRuntime = async () => {
+  const clients = [...registry.clients];
+  const statuses = clients.map((client) => client.status());
+  const deadLetters = (await Promise.all(clients.map((client) => client.listDeadLetters()))).flat().map((record) => ({
+    attempts: record.attempts,
+    ...record.rejection?.code ? { code: record.rejection.code } : {},
+    createdAt: record.createdAt,
+    ...record.deadLetteredAt === undefined ? {} : { deadLetteredAt: record.deadLetteredAt },
+    ...record.rejection?.kind ? { kind: record.rejection.kind } : {},
+    ...record.rejection?.message ? { message: record.rejection.message } : {},
+    name: record.name,
+    operationId: record.operationId
+  })).sort((left, right) => (left.deadLetteredAt ?? left.createdAt) - (right.deadLetteredAt ?? right.createdAt) || left.operationId.localeCompare(right.operationId));
+  const lastError = statuses.findLast((status) => status.lastError)?.lastError;
+  return {
+    automaticResolutions: statuses.reduce((total, status) => total + status.automaticResolutions, 0),
+    clients: clients.length,
+    conflicts: deadLetters.filter((record) => record.kind === "conflict").length,
+    deadLetters,
+    ...lastError ? { lastError } : {},
+    ...maximum(statuses.map((status) => status.lastSuccessfulPullAt)) === undefined ? {} : {
+      lastSuccessfulPullAt: maximum(statuses.map((status) => status.lastSuccessfulPullAt))
+    },
+    ...maximum(statuses.map((status) => status.lastSuccessfulPushAt)) === undefined ? {} : {
+      lastSuccessfulPushAt: maximum(statuses.map((status) => status.lastSuccessfulPushAt))
+    },
+    ...minimum(statuses.map((status) => status.oldestDeadLetterAt)) === undefined ? {} : {
+      oldestDeadLetterAt: minimum(statuses.map((status) => status.oldestDeadLetterAt))
+    },
+    ...minimum(statuses.map((status) => status.oldestPendingAt)) === undefined ? {} : {
+      oldestPendingAt: minimum(statuses.map((status) => status.oldestPendingAt))
+    },
+    pending: statuses.reduce((total, status) => total + status.pending, 0)
+  };
+};
+var clientWithDeadLetter = async (operationId) => {
+  for (const client of registry.clients)
+    if ((await client.listDeadLetters()).some((record) => record.operationId === operationId))
+      return client;
+  throw new Error(`Unknown Sync dead letter "${operationId}"`);
+};
+var retrySyncRuntimeDeadLetter = async (operationId) => (await clientWithDeadLetter(operationId)).retryDeadLetter(operationId);
+var discardSyncRuntimeDeadLetter = async (operationId) => (await clientWithDeadLetter(operationId)).discardDeadLetter(operationId);
+var rebaseSyncRuntimeDeadLetter = async (operationId, args) => (await clientWithDeadLetter(operationId)).rebaseDeadLetter(operationId, args);
+
+// src/mobile/syncRemediation.ts
+var REMEDIATION_REGISTRY = Symbol.for("@absolutejs/mobile-sync-remediation");
+var LAST_INSTALLATION_OFFSET = -1;
+var isRegistry2 = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations"));
+var resolveRegistry = () => {
+  const existing = Reflect.get(globalThis, REMEDIATION_REGISTRY);
+  if (isRegistry2(existing))
+    return existing;
+  const created = { installations: [] };
+  Object.defineProperty(globalThis, REMEDIATION_REGISTRY, {
+    configurable: false,
+    enumerable: false,
+    value: created,
+    writable: false
+  });
+  return created;
+};
+var registry2 = resolveRegistry();
+var getAbsoluteMobileSyncRemediation = () => registry2.installations.at(LAST_INSTALLATION_OFFSET)?.bridge;
+var installAbsoluteMobileSyncRemediation = (bridge = {
+  discard: discardSyncRuntimeDeadLetter,
+  inspect: inspectSyncRuntime,
+  rebase: rebaseSyncRuntimeDeadLetter,
+  retry: retrySyncRuntimeDeadLetter
+}) => {
+  const installation = { bridge };
+  registry2.installations.push(installation);
+  return () => {
+    const index = registry2.installations.indexOf(installation);
+    if (index >= 0)
+      registry2.installations.splice(index, 1);
+  };
+};
+// src/mobile/uiPrimitives.ts
+var STYLE_ID = "absolute-mobile-ui-primitives";
+var NAVIGATION_EVENT = "absolute:navigation-change";
+var SHEET_EVENT = "absolute:sheet-change";
+var BACK_EVENT = "absolute:back-request";
+var ACTIVE_SHEET_SELECTOR = "dialog[data-absolute-sheet][open]";
+var TAB_LINK_SELECTOR = "[data-absolute-tab-bar] a[href]";
+var UI_STYLE = `
+[data-absolute-app-shell] {
+	display: grid;
+	grid-template-rows: auto minmax(0, 1fr) auto;
+	box-sizing: border-box;
+	min-height: var(--absolute-available-height, 100dvh);
+	padding-inline: var(--absolute-safe-area-inset-left, 0px) var(--absolute-safe-area-inset-right, 0px);
+}
+[data-absolute-app-header] {
+	padding-top: var(--absolute-safe-area-inset-top, 0px);
+}
+[data-absolute-app-main], [data-absolute-navigation-stack] {
+	min-width: 0;
+	min-height: 0;
+}
+[data-absolute-app-main] {
+	overflow: auto;
+	overscroll-behavior-y: contain;
+}
+[data-absolute-navigation-stack] {
+	view-transition-name: absolute-mobile-stack;
+}
+[data-absolute-tab-bar] {
+	display: flex;
+	align-items: stretch;
+	justify-content: space-around;
+	box-sizing: border-box;
+	padding-bottom: var(--absolute-safe-area-inset-bottom, 0px);
+	background: Canvas;
+	color: CanvasText;
+}
+[data-absolute-tab-bar] > a {
+	display: grid;
+	flex: 1 1 0;
+	min-width: 0;
+	min-height: 2.75rem;
+	place-items: center;
+	padding: 0.375rem 0.5rem;
+	color: inherit;
+	text-align: center;
+	text-decoration: none;
+	touch-action: manipulation;
+}
+[data-absolute-tab-bar] > a[aria-current="page"] {
+	font-weight: 700;
+}
+dialog[data-absolute-sheet] {
+	box-sizing: border-box;
+	width: min(100%, var(--absolute-sheet-max-width, 42rem));
+	max-height: min(90dvh, var(--absolute-available-height, 90dvh));
+	margin: auto auto 0;
+	padding: 1rem max(1rem, var(--absolute-safe-area-inset-right, 0px)) max(1rem, var(--absolute-safe-area-inset-bottom, 0px)) max(1rem, var(--absolute-safe-area-inset-left, 0px));
+	overflow: auto;
+	border: 1px solid color-mix(in srgb, CanvasText 18%, transparent);
+	border-radius: 1rem 1rem 0 0;
+	background: Canvas;
+	color: CanvasText;
+	box-shadow: 0 -0.5rem 2rem color-mix(in srgb, CanvasText 18%, transparent);
+}
+dialog[data-absolute-sheet]::backdrop {
+	background: color-mix(in srgb, CanvasText 38%, transparent);
+}
+@keyframes absolute-mobile-forward-old { to { opacity: 0; transform: translateX(-12%); } }
+@keyframes absolute-mobile-forward-new { from { opacity: 0; transform: translateX(12%); } }
+@keyframes absolute-mobile-back-old { to { opacity: 0; transform: translateX(12%); } }
+@keyframes absolute-mobile-back-new { from { opacity: 0; transform: translateX(-12%); } }
+html[data-absolute-navigation-direction="forward"]::view-transition-old(absolute-mobile-stack) { animation: 180ms ease both absolute-mobile-forward-old; }
+html[data-absolute-navigation-direction="forward"]::view-transition-new(absolute-mobile-stack) { animation: 180ms ease both absolute-mobile-forward-new; }
+html[data-absolute-navigation-direction="back"]::view-transition-old(absolute-mobile-stack) { animation: 180ms ease both absolute-mobile-back-old; }
+html[data-absolute-navigation-direction="back"]::view-transition-new(absolute-mobile-stack) { animation: 180ms ease both absolute-mobile-back-new; }
+html[data-absolute-reduced-motion="reduce"]::view-transition-old(absolute-mobile-stack),
+html[data-absolute-reduced-motion="reduce"]::view-transition-new(absolute-mobile-stack) { animation: none; }
+`;
+var currentPath = () => `${location.pathname}${location.search}${location.hash}`;
+var ensureStyle = () => {
+  let style = document.getElementById(STYLE_ID);
+  if (!(style instanceof HTMLStyleElement)) {
+    style = document.createElement("style");
+    style.id = STYLE_ID;
+    style.textContent = UI_STYLE;
+    document.head.append(style);
+  }
+};
+var sheetById = (id) => {
+  const target = document.getElementById(id);
+  return target instanceof HTMLDialogElement && target.dataset.absoluteSheet !== undefined ? target : undefined;
+};
+var dispatchSheet = (sheet, open) => dispatchEvent(new CustomEvent(SHEET_EVENT, {
+  detail: { id: sheet.id, open }
+}));
+var focusSheet = (sheet) => {
+  const target = sheet.querySelector('[autofocus], button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])');
+  (target ?? sheet).focus();
+};
+var sheetOpeners = new WeakMap;
+var closeAbsoluteMobileSheet = (target) => {
+  const sheet = typeof target === "string" ? sheetById(target) : target;
+  if (!sheet || !sheet.open)
+    return false;
+  if (typeof sheet.close === "function")
+    sheet.close();
+  else
+    sheet.removeAttribute("open");
+  sheet.removeAttribute("aria-modal");
+  sheetOpeners.get(sheet)?.focus();
+  sheetOpeners.delete(sheet);
+  dispatchSheet(sheet, false);
+  return true;
+};
+var openAbsoluteMobileSheet = (target, opener) => {
+  const sheet = typeof target === "string" ? sheetById(target) : target;
+  if (!sheet || sheet.dataset.absoluteSheet === undefined)
+    return false;
+  const active = document.querySelector(ACTIVE_SHEET_SELECTOR);
+  if (active && active !== sheet)
+    closeAbsoluteMobileSheet(active);
+  if (opener)
+    sheetOpeners.set(sheet, opener);
+  if (!sheet.open) {
+    if (typeof sheet.showModal === "function")
+      sheet.showModal();
+    else
+      sheet.setAttribute("open", "");
+  }
+  sheet.setAttribute("aria-modal", "true");
+  focusSheet(sheet);
+  dispatchSheet(sheet, true);
+  return true;
+};
+var readAbsoluteMobileLinkIntent = (anchor) => {
+  const mode = anchor.dataset.absoluteLink;
+  if (mode === "back")
+    return { kind: "back" };
+  if (mode === "external")
+    return { kind: "external" };
+  return { kind: "navigate", replace: mode === "replace" };
+};
+var requestAbsoluteMobileBack = () => {
+  const event = new CustomEvent(BACK_EVENT, { cancelable: true });
+  return !dispatchEvent(event);
+};
+var normalizePathname = (value) => {
+  try {
+    return new URL(value, location.href).pathname.replace(/\/$/u, "") || "/";
+  } catch {
+    return;
+  }
+};
+var syncTabLinks = (path) => {
+  const activePath = normalizePathname(path);
+  if (!activePath)
+    return;
+  document.querySelectorAll(TAB_LINK_SELECTOR).forEach((anchor) => {
+    const candidate = normalizePathname(anchor.href);
+    const prefix = anchor.dataset.absoluteTabMatch === "prefix";
+    const active = candidate !== undefined && (prefix ? activePath === candidate || candidate !== "/" && activePath.startsWith(`${candidate}/`) : activePath === candidate);
+    if (active)
+      anchor.setAttribute("aria-current", "page");
+    else
+      anchor.removeAttribute("aria-current");
+  });
+};
+var installAbsoluteMobileUiPrimitives = () => {
+  let disposed = false;
+  let scheduled = false;
+  let path = currentPath();
+  const refreshDocument = (nextPath = path) => {
+    if (disposed || !document.head || !document.body)
+      return;
+    path = nextPath;
+    ensureStyle();
+    syncTabLinks(path);
+  };
+  const scheduleRefresh = () => {
+    if (scheduled || disposed)
+      return;
+    scheduled = true;
+    queueMicrotask(() => {
+      scheduled = false;
+      refreshDocument();
+    });
+  };
+  const handleClick = (event) => {
+    if (!(event.target instanceof Element))
+      return;
+    const opener = event.target.closest("[data-absolute-sheet-open]");
+    if (opener?.dataset.absoluteSheetOpen) {
+      if (openAbsoluteMobileSheet(opener.dataset.absoluteSheetOpen, opener))
+        event.preventDefault();
+      return;
+    }
+    const closer = event.target.closest("[data-absolute-sheet-close]");
+    const sheet = closer?.closest("dialog[data-absolute-sheet]");
+    if (sheet && closeAbsoluteMobileSheet(sheet)) {
+      event.preventDefault();
+      return;
+    }
+    if (event.target instanceof HTMLDialogElement && event.target.dataset.absoluteSheet !== undefined) {
+      const rect = event.target.getBoundingClientRect();
+      const outside = event.clientX < rect.left || event.clientX > rect.right || event.clientY < rect.top || event.clientY > rect.bottom;
+      if (outside && closeAbsoluteMobileSheet(event.target))
+        event.preventDefault();
+    }
+  };
+  const handleCancel = (event) => {
+    if (!(event.target instanceof HTMLDialogElement))
+      return;
+    if (event.target.dataset.absoluteSheet === undefined)
+      return;
+    event.preventDefault();
+    closeAbsoluteMobileSheet(event.target);
+  };
+  const handleBack = (event) => {
+    const active = document.querySelector(ACTIVE_SHEET_SELECTOR);
+    if (!active)
+      return;
+    event.preventDefault();
+    closeAbsoluteMobileSheet(active);
+  };
+  const observer = new MutationObserver(scheduleRefresh);
+  observer.observe(document.documentElement, {
+    childList: true,
+    subtree: true
+  });
+  addEventListener("click", handleClick);
+  addEventListener("cancel", handleCancel, true);
+  addEventListener(BACK_EVENT, handleBack);
+  refreshDocument();
+  return {
+    refreshDocument,
+    requestBack: requestAbsoluteMobileBack,
+    dispose: () => {
+      if (disposed)
+        return;
+      disposed = true;
+      observer.disconnect();
+      removeEventListener("click", handleClick);
+      removeEventListener("cancel", handleCancel, true);
+      removeEventListener(BACK_EVENT, handleBack);
+    },
+    navigate: (detail) => {
+      path = detail.to;
+      document.documentElement.dataset.absoluteNavigationDirection = detail.direction;
+      refreshDocument(path);
+      dispatchEvent(new CustomEvent(NAVIGATION_EVENT, {
+        detail
+      }));
+    }
+  };
+};
 export {
-  parseAbsoluteMobilePageRequest,
-  parseAbsoluteMobilePageEnvelope,
-  finalizeAbsoluteMobilePage,
-  disposeAbsoluteMobilePage,
-  createAbsoluteMobileUpgradeResponse,
-  createAbsoluteMobilePageErrorResponse,
-  createAbsoluteMobileInvalidRequestResponse,
-  activateAbsoluteMobilePage,
-  acceptsAbsoluteMobilePage,
-  MOBILE_PAGE_REQUEST_HEADERS,
-  AbsoluteMobilePageProtocolError,
+  ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE,
   ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
-  ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE
+  ABSOLUTE_NATIVE_ROUTE_DATA_MEDIA_TYPE,
+  AbsoluteMobilePageProtocolError,
+  MOBILE_PAGE_REQUEST_HEADERS,
+  acceptsAbsoluteMobilePage,
+  acceptsAbsoluteNativeRouteData,
+  activateAbsoluteMobilePage,
+  closeAbsoluteMobileSheet,
+  createAbsoluteMobileInvalidRequestResponse,
+  createAbsoluteMobilePageErrorResponse,
+  createAbsoluteMobileUpgradeResponse,
+  disposeAbsoluteMobilePage,
+  finalizeAbsoluteMobilePage,
+  getAbsoluteMobileSyncRemediation,
+  installAbsoluteMobileSyncRemediation,
+  installAbsoluteMobileUiPrimitives,
+  openAbsoluteMobileSheet,
+  parseAbsoluteMobilePageEnvelope,
+  parseAbsoluteMobilePageRequest,
+  readAbsoluteMobileLinkIntent,
+  requestAbsoluteMobileBack
 };
 
-//# debugId=0E2FF4B3FE304DB264756E2164756E21
+//# debugId=443B7836F42C181D64756E2164756E21
 //# sourceMappingURL=browser.js.map