@absolutejs/absolute 0.20.0-beta.57 → 0.20.0-beta.59

package/dist/mobile/shellSync.js

@@ -107,17 +107,28 @@ var installAbsoluteMobileShellSync = (auth, config, options = {}) => {
   const reportSchemaState = options.reportSchemaState ?? reportShellSchemaState;
   const configureBackground = options.configureBackground ?? configureCapacitorBackgroundSync;
   const clearBackground = options.clearBackground ?? (() => AbsoluteBackgroundSync.clear());
+  let schemaReady = Promise.resolve(true);
   if (store?.getSchemaStatus) {
     reportSchemaState({ state: "preparing" });
-    store.getSchemaStatus().then(reportSchemaState).catch((error) => reportSchemaState(schemaFailureState(error)));
+    schemaReady = store.getSchemaStatus().then((state) => {
+      reportSchemaState(state);
+      return true;
+    }).catch((error) => {
+      reportSchemaState(schemaFailureState(error));
+      return false;
+    });
   }
   if (namespace && config) {
-    configureBackground({
-      clientId: auth.clientId,
-      endpoint: config.background.endpoint,
-      intervalMinutes: config.background.intervalMinutes,
-      issuer: auth.issuer,
-      namespace
+    schemaReady.then((ready) => {
+      if (!ready)
+        return;
+      return configureBackground({
+        clientId: auth.clientId,
+        endpoint: config.background.endpoint,
+        intervalMinutes: config.background.intervalMinutes,
+        issuer: auth.issuer,
+        namespace
+      });
     }).catch((error) => console.error("[Absolute Mobile] Background Sync configuration failed:", error));
   } else {
     clearBackground().catch(() => {

package/dist/mobile/uiPrimitives.js

@@ -0,0 +1,264 @@
+// 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 {
+  closeAbsoluteMobileSheet,
+  installAbsoluteMobileUiPrimitives,
+  openAbsoluteMobileSheet,
+  readAbsoluteMobileLinkIntent,
+  requestAbsoluteMobileBack
+};

package/dist/src/mobile/browser.d.ts

@@ -1,3 +1,4 @@
 export * from './client';
 export * from './pageProtocol';
 export * from './syncRemediation';
+export * from './uiPrimitives';

package/dist/src/mobile/index.d.ts

@@ -39,3 +39,4 @@ export * from './routeMetadataTransform';
 export * from './routeMatcher';
 export * from './shellHttp';
 export * from './transport';
+export * from './uiPrimitives';

package/dist/src/mobile/navigationLifecycle.d.ts

@@ -0,0 +1,36 @@
+export type AbsoluteMobileNavigationHistoryMode = 'none' | 'push' | 'replace';
+export type AbsoluteMobileNavigationRequest = {
+    direction: 'back' | 'forward' | 'replace';
+    from: string;
+    historyMode: AbsoluteMobileNavigationHistoryMode;
+    path: string;
+};
+export type AbsoluteMobileNavigationFailurePhase = 'commit' | 'load';
+export type AbsoluteMobileNavigationResult = {
+    kind: 'cancelled';
+} | {
+    kind: 'committed';
+} | {
+    kind: 'failed';
+    error: unknown;
+    phase: AbsoluteMobileNavigationFailurePhase;
+};
+export type AbsoluteMobileNavigationCoordinatorOptions<Payload> = {
+    commit: (payload: Payload, request: AbsoluteMobileNavigationRequest) => Promise<void>;
+    load: (request: AbsoluteMobileNavigationRequest, signal: AbortSignal) => Promise<Payload>;
+    onCommit?: (request: AbsoluteMobileNavigationRequest) => void;
+    onFailure?: (error: unknown, phase: AbsoluteMobileNavigationFailurePhase, request: AbsoluteMobileNavigationRequest) => void;
+    onStart?: (request: AbsoluteMobileNavigationRequest) => void;
+    onSuccess?: (request: AbsoluteMobileNavigationRequest) => void;
+};
+export type AbsoluteMobileNavigationCoordinator = {
+    cancelPending(): boolean;
+    dispose(): void;
+    navigate(request: AbsoluteMobileNavigationRequest): Promise<AbsoluteMobileNavigationResult>;
+    phase(): 'committing' | 'idle' | 'loading' | 'queued';
+};
+/**
+ * Coordinates native-shell route loads. Loads may overlap, but only the latest
+ * completed load may enter the serialized document commit boundary.
+ */
+export declare const createAbsoluteMobileNavigationCoordinator: <Payload>(options: AbsoluteMobileNavigationCoordinatorOptions<Payload>) => AbsoluteMobileNavigationCoordinator;

package/dist/src/mobile/navigationState.d.ts

@@ -0,0 +1,53 @@
+export type AbsoluteMobileHistoryEntry = {
+    absoluteMobile: true;
+    entryId: string;
+    index: number;
+    path: string;
+};
+type ElementLocator = {
+    kind: 'id';
+    value: string;
+} | {
+    kind: 'index';
+    index: number;
+} | {
+    kind: 'name';
+    index: number;
+    value: string;
+};
+type ControlSnapshot = {
+    checked?: boolean;
+    locator: ElementLocator;
+    open?: boolean;
+    selectionEnd?: number;
+    selectionStart?: number;
+    tag: string;
+    value?: string;
+    values?: string[];
+};
+type ScrollSnapshot = {
+    left: number;
+    locator: ElementLocator;
+    top: number;
+};
+export type AbsoluteMobileDocumentSnapshot = {
+    controls: ControlSnapshot[];
+    focus?: ElementLocator;
+    scroll: ScrollSnapshot[];
+    window: {
+        x: number;
+        y: number;
+    };
+};
+export declare const createAbsoluteMobileHistoryEntry: (path: string, index: number, entryId?: string) => {
+    absoluteMobile: true;
+    entryId: string;
+    index: number;
+    path: string;
+};
+export declare const readAbsoluteMobileHistoryEntry: (value: unknown) => AbsoluteMobileHistoryEntry | undefined;
+/** Captures route-local state in memory. Sensitive credential fields are omitted. */
+export declare const captureAbsoluteMobileDocumentState: () => AbsoluteMobileDocumentSnapshot;
+export declare const restoreAbsoluteMobileDocumentState: (snapshot: AbsoluteMobileDocumentSnapshot) => void;
+export declare const resetAbsoluteMobileDocumentState: () => void;
+export {};

package/dist/src/mobile/transport.d.ts

@@ -34,6 +34,7 @@ export type AbsoluteMobileClientManifest = {
 export type AbsoluteMobileTransportOptions = {
     fetch?: AbsoluteMobileFetch;
     headers?: HeadersInit;
+    signal?: AbortSignal;
 };
 export declare const createAbsoluteMobilePageRequest: (manifest: AbsoluteMobileClientManifest, path: string, options?: AbsoluteMobileTransportOptions) => Request;
 export declare const fetchAbsoluteMobilePage: (manifest: AbsoluteMobileClientManifest, path: string, options?: AbsoluteMobileTransportOptions) => Promise<unknown>;

package/dist/src/mobile/uiPrimitives.d.ts

@@ -0,0 +1,37 @@
+export type AbsoluteMobileNavigationDirection = 'back' | 'forward' | 'replace';
+export type AbsoluteMobileNavigationDetail = {
+    direction: AbsoluteMobileNavigationDirection;
+    from: string;
+    to: string;
+};
+export type AbsoluteMobileSheetDetail = {
+    id: string;
+    open: boolean;
+};
+export type AbsoluteMobileLinkIntent = {
+    kind: 'back';
+} | {
+    kind: 'external';
+} | {
+    kind: 'navigate';
+    replace: boolean;
+};
+declare global {
+    interface WindowEventMap {
+        'absolute:back-request': CustomEvent;
+        'absolute:navigation-change': CustomEvent<AbsoluteMobileNavigationDetail>;
+        'absolute:sheet-change': CustomEvent<AbsoluteMobileSheetDetail>;
+    }
+}
+export type AbsoluteMobileUiPrimitives = {
+    dispose(): void;
+    navigate(detail: AbsoluteMobileNavigationDetail): void;
+    refreshDocument(path?: string): void;
+    requestBack(): boolean;
+};
+export declare const closeAbsoluteMobileSheet: (target: HTMLDialogElement | string) => boolean;
+export declare const openAbsoluteMobileSheet: (target: HTMLDialogElement | string, opener?: HTMLElement) => boolean;
+export declare const readAbsoluteMobileLinkIntent: (anchor: HTMLAnchorElement) => AbsoluteMobileLinkIntent;
+export declare const requestAbsoluteMobileBack: () => boolean;
+/** Installs optional semantic-HTML mobile layout and interaction primitives. */
+export declare const installAbsoluteMobileUiPrimitives: () => AbsoluteMobileUiPrimitives;

package/package.json

@@ -152,6 +152,10 @@
 			"import": "./dist/mobile/index.js",
 			"types": "./dist/src/mobile/index.d.ts"
 		},
+		"./mobile/ui": {
+			"import": "./dist/mobile/uiPrimitives.js",
+			"types": "./dist/src/mobile/uiPrimitives.d.ts"
+		},
 		"./react": {
 			"browser": "./dist/react/browser.js",
 			"import": "./dist/react/index.js",
@@ -289,12 +293,12 @@
 	"main": "./dist/index.js",
 	"name": "@absolutejs/absolute",
 	"optionalDependencies": {
-		"@absolutejs/native-darwin-arm64": "0.20.0-beta.57",
-		"@absolutejs/native-darwin-x64": "0.20.0-beta.57",
-		"@absolutejs/native-linux-arm64": "0.20.0-beta.57",
-		"@absolutejs/native-linux-x64": "0.20.0-beta.57",
-		"@absolutejs/native-windows-arm64": "0.20.0-beta.57",
-		"@absolutejs/native-windows-x64": "0.20.0-beta.57"
+		"@absolutejs/native-darwin-arm64": "0.20.0-beta.59",
+		"@absolutejs/native-darwin-x64": "0.20.0-beta.59",
+		"@absolutejs/native-linux-arm64": "0.20.0-beta.59",
+		"@absolutejs/native-linux-x64": "0.20.0-beta.59",
+		"@absolutejs/native-windows-arm64": "0.20.0-beta.59",
+		"@absolutejs/native-windows-x64": "0.20.0-beta.59"
 	},
 	"overrides": {
 		"@sinclair/typebox": "0.34.52",
@@ -510,7 +514,7 @@
 			]
 		}
 	},
-	"version": "0.20.0-beta.57",
+	"version": "0.20.0-beta.59",
 	"workspaces": [
 		"tests/fixtures/*",
 		"tests/fixtures/_packages/*"