@protobase/ui 0.57.3 → 0.57.4

package/dist/app/app.js

@@ -61,6 +61,7 @@ import { NewVersionToast } from "./new-version/new-version-toast.js";
 import { RuntimeUpdateButton } from "./runtime/runtime-update.js";
 import { StaffBanner } from "./staff-banner.js";
 import { useNavRecent } from "./use-nav-recent.js";
+import { LiveUpdateGate } from "./live-update/live-update-gate.js";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { viewOfList } from "@protobase/schema/internal";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
@@ -321,27 +322,32 @@ const PublicFormGate = ({ baseUrl, client, ui, children }) => {
 */
 const App = ({ auth, workspace, basePath, initialUrl, pluginLoader, locale, nativeBridge, ...rest }) => {
 	setFallbackLocale(locale ?? "en");
-	return /* @__PURE__ */ jsx(ThemeProvider, { children: /* @__PURE__ */ jsx(AuthProvider, {
-		session: auth,
-		...rest.baseUrl && { origin: new URL(rest.baseUrl, window.location.href).origin },
-		...nativeBridge && { nativeBridge },
-		children: /* @__PURE__ */ jsx(Router, {
-			basePath,
-			initialUrl,
-			children: /* @__PURE__ */ jsx(PluginSourceProvider, {
-				...pluginLoader && { loader: pluginLoader },
-				children: /* @__PURE__ */ jsx(AuthLocale, { children: /* @__PURE__ */ jsx(PublicFormGate, {
-					baseUrl: rest.baseUrl,
-					client: rest.client,
-					ui: rest.ui,
-					children: /* @__PURE__ */ jsx(AuthGate, {
-						workspace,
-						children: /* @__PURE__ */ jsx(Authenticated, {
+	const apiOrigin = rest.baseUrl && new URL(rest.baseUrl, window.location.href).origin;
+	return /* @__PURE__ */ jsx(ThemeProvider, { children: /* @__PURE__ */ jsx(LiveUpdateGate, {
+		nativeBridge,
+		apiOrigin,
+		children: /* @__PURE__ */ jsx(AuthProvider, {
+			session: auth,
+			...apiOrigin && { origin: apiOrigin },
+			...nativeBridge && { nativeBridge },
+			children: /* @__PURE__ */ jsx(Router, {
+				basePath,
+				initialUrl,
+				children: /* @__PURE__ */ jsx(PluginSourceProvider, {
+					...pluginLoader && { loader: pluginLoader },
+					children: /* @__PURE__ */ jsx(AuthLocale, { children: /* @__PURE__ */ jsx(PublicFormGate, {
+						baseUrl: rest.baseUrl,
+						client: rest.client,
+						ui: rest.ui,
+						children: /* @__PURE__ */ jsx(AuthGate, {
 							workspace,
-							...rest
+							children: /* @__PURE__ */ jsx(Authenticated, {
+								workspace,
+								...rest
+							})
 						})
-					})
-				}) })
+					}) })
+				})
 			})
 		})
 	}) });

package/dist/app/live-update/app-live-updater.js

@@ -0,0 +1,31 @@
+import { protobaseVersion } from "../../plugins/plugin-api.js";
+import { createLiveUpdater } from "./live-updater.js";
+import { nativeFingerprintOf } from "./native-fingerprint.js";
+import { checkRelease } from "./release-check.js";
+import { mobileReleasesPath } from "@protobase/schema/internal";
+//#region src/app/live-update/app-live-updater.ts
+/**
+* The live updater of the app the page runs in: `undefined` in a browser, and in a binary without the live updater,
+* such as the iOS app, or one built without `mobile.publicKey`. It asks the server only with the binary's fingerprint
+* and the API origin the page names; without them it only tells the plugin the files started.
+*/
+const appLiveUpdater = ({ bridge, apiOrigin, userAgent, fetch, onHold }) => {
+	if (!bridge?.Exception || !bridge.isPluginAvailable("LiveUpdate")) return;
+	const fingerprint = nativeFingerprintOf(userAgent);
+	const check = async () => fingerprint && apiOrigin ? checkRelease(fetch, {
+		apiOrigin,
+		fingerprint,
+		shellVersion: protobaseVersion
+	}) : void 0;
+	return createLiveUpdater({
+		bridge: {
+			nativePromise: bridge.nativePromise.bind(bridge),
+			Exception: bridge.Exception
+		},
+		check,
+		releasesUrl: `${apiOrigin}${mobileReleasesPath}`,
+		onHold
+	});
+};
+//#endregion
+export { appLiveUpdater };

package/dist/app/live-update/live-update-gate.js

@@ -0,0 +1,39 @@
+import { Notice } from "../meta-gate.js";
+import { appLiveUpdater } from "./app-live-updater.js";
+import { text } from "./messages.js";
+import { useEffect, useMemo, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/app/live-update/live-update-gate.tsx
+/**
+* The live updater in the iOS or Android app, around everything the shell draws. Once the shell has drawn, it tells
+* the plugin the files started, so a release that fails before then goes back to the app's own; then it checks for a
+* release, at launch and each time the app comes back to the foreground, in the background. Only a required release
+* at launch holds the app, with a notice, until it reloads into it or goes on without it.
+*/
+const LiveUpdateGate = ({ nativeBridge, apiOrigin, children }) => {
+	const [holding, setHolding] = useState(false);
+	const updater = useMemo(() => appLiveUpdater({
+		bridge: nativeBridge,
+		apiOrigin,
+		userAgent: navigator.userAgent,
+		fetch: window.fetch.bind(window),
+		onHold: setHolding
+	}), [nativeBridge, apiOrigin]);
+	useEffect(() => {
+		if (!updater) return;
+		updater.ready();
+		updater.check(true);
+		const onVisible = () => {
+			if (document.visibilityState === "visible") updater.check(false);
+		};
+		document.addEventListener("visibilitychange", onVisible);
+		return () => document.removeEventListener("visibilitychange", onVisible);
+	}, [updater]);
+	if (holding) return /* @__PURE__ */ jsx(Notice, {
+		title: text("holdTitle"),
+		children: text("holdLine")
+	});
+	return children;
+};
+//#endregion
+export { LiveUpdateGate };

package/dist/app/live-update/live-updater.js

@@ -0,0 +1,74 @@
+import { swapDecision } from "./swap-decision.js";
+//#region src/app/live-update/live-updater.ts
+/** How long a required update may hold the app at launch before it goes on with the files it runs. */
+const requiredUpdateTimeoutMs = 6e4;
+const bundleIdOf = (result) => {
+	const id = typeof result === "object" && result !== null ? result.bundleId : void 0;
+	return typeof id === "string" ? id : null;
+};
+/**
+* The app's side of the live updater, through Protobase's guarded LiveUpdate plugin, which checks every release
+* itself. `ready()` tells the plugin the files the app runs started; `check(launch)` asks the server and takes a new
+* release for the next cold start, one check at a time. A release the guard refuses, or a call that fails, leaves the
+* app on the files it runs.
+*/
+const createLiveUpdater = ({ bridge, check, releasesUrl, onHold }) => {
+	const call = (method, options = {}) => bridge.nativePromise("LiveUpdate", method, options);
+	const refused = (error) => error instanceof bridge.Exception;
+	const take = async (bundleId, download) => {
+		if (download) await call("downloadBundle", {
+			bundleId,
+			url: `${releasesUrl}/${bundleId}`,
+			artifactType: "manifest"
+		});
+		await call("setNextBundle", { bundleId });
+	};
+	const takeHolding = async (bundleId, download) => {
+		let holding = true;
+		const release = () => {
+			if (!holding) return;
+			holding = false;
+			onHold(false);
+		};
+		onHold(true);
+		const timer = setTimeout(release, requiredUpdateTimeoutMs);
+		try {
+			await take(bundleId, download);
+			if (holding) await call("reload");
+		} finally {
+			clearTimeout(timer);
+			release();
+		}
+	};
+	const run = async (launch) => {
+		const [answer, current, next] = await Promise.all([
+			check(),
+			call("getCurrentBundle"),
+			call("getNextBundle")
+		]);
+		const swap = swapDecision({
+			answer,
+			current: bundleIdOf(current),
+			next: bundleIdOf(next),
+			launch
+		});
+		if (swap.kind === "none") return;
+		try {
+			await (swap.reload ? takeHolding(swap.bundleId, swap.download) : take(swap.bundleId, swap.download));
+		} catch (error) {
+			if (!refused(error)) throw error;
+		}
+	};
+	let running;
+	return {
+		ready: () => call("ready"),
+		check: (launch) => {
+			running ??= run(launch).finally(() => {
+				running = void 0;
+			});
+			return running;
+		}
+	};
+};
+//#endregion
+export { createLiveUpdater, requiredUpdateTimeoutMs };

package/dist/app/live-update/messages.js

@@ -0,0 +1,14 @@
+import { defineMessages } from "../../locale/messages.js";
+//#region src/app/live-update/messages.ts
+const text = defineMessages({
+	en: {
+		holdTitle: "Updating the app",
+		holdLine: "The new version is downloading. The app opens it in a moment."
+	},
+	nl: {
+		holdTitle: "De app wordt bijgewerkt",
+		holdLine: "De nieuwe versie wordt gedownload. De app opent die zo."
+	}
+});
+//#endregion
+export { text };

package/dist/app/live-update/native-fingerprint.js

@@ -0,0 +1,8 @@
+//#region src/app/live-update/native-fingerprint.ts
+/**
+* The native fingerprint the iOS or Android binary names in its user agent, `ProtobaseNative/<fingerprint>`, which
+* `protobase mobile` writes beside the app's files: `undefined` without one.
+*/
+const nativeFingerprintOf = (userAgent) => /(?:^|\s)ProtobaseNative\/([0-9a-f]{16})(?:\s|$)/.exec(userAgent)?.[1];
+//#endregion
+export { nativeFingerprintOf };

package/dist/app/live-update/release-answer.js

@@ -0,0 +1,22 @@
+//#region src/app/live-update/release-answer.ts
+const bundleIdPattern = /^[A-Za-z0-9_-]{1,64}$/;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* The server's answer to `GET /api/mobile/release` when it is one: `bundleId` a safe id or null, `url` a string or null
+* and `required` a boolean. Any other body is `undefined`, which changes nothing; fields a later server adds are
+* ignored.
+*/
+const releaseAnswerOf = (body) => {
+	if (!isRecord(body)) return;
+	const { bundleId, url, required } = body;
+	if (bundleId !== null && (typeof bundleId !== "string" || !bundleIdPattern.test(bundleId))) return;
+	if (url !== null && typeof url !== "string") return;
+	if (typeof required !== "boolean") return;
+	return {
+		bundleId,
+		url,
+		required
+	};
+};
+//#endregion
+export { releaseAnswerOf };

package/dist/app/live-update/release-check.js

@@ -0,0 +1,31 @@
+import { releaseAnswerOf } from "./release-answer.js";
+import { mobileReleasePath, mobileReleaseQuery } from "@protobase/schema/internal";
+//#region src/app/live-update/release-check.ts
+/** How long the app waits for the server's answer before it goes on with the files it runs. */
+const releaseCheckTimeoutMs = 15e3;
+const noAnswer = (error) => error instanceof TypeError || error instanceof DOMException && error.name === "TimeoutError";
+/**
+* Asks the app's server which release this binary should run. `undefined` for anything but a 200 holding the answer:
+* a 503 while the server starts, a 500, no network, the timeout or another body, after which the app keeps the files
+* it runs. The route is public, so no credentials go with it.
+*/
+const checkRelease = async (fetch, { apiOrigin, fingerprint, shellVersion }) => {
+	const url = `${apiOrigin}${mobileReleasePath}?${mobileReleaseQuery({
+		fingerprint,
+		shellVersion
+	})}`;
+	try {
+		const response = await fetch(url, {
+			credentials: "omit",
+			cache: "no-store",
+			signal: AbortSignal.timeout(releaseCheckTimeoutMs)
+		});
+		if (response.status !== 200) return;
+		return releaseAnswerOf(await response.json());
+	} catch (error) {
+		if (noAnswer(error) || error instanceof SyntaxError) return;
+		throw error;
+	}
+};
+//#endregion
+export { checkRelease, releaseCheckTimeoutMs };

package/dist/app/live-update/swap-decision.js

@@ -0,0 +1,20 @@
+//#region src/app/live-update/swap-decision.ts
+/**
+* The live updater's rules. A release the app does not run is downloaded and set as the next bundle, which it runs at
+* its next cold start; at launch, a required one is also reloaded into at once. A release it runs, no release, or no
+* answer changes nothing: the answer is not signed, so it never takes the app back to its own files, which only a
+* release that fails to start does.
+*/
+const swapDecision = ({ answer, current, next, launch }) => {
+	if (!answer?.bundleId || answer.bundleId === current) return { kind: "none" };
+	const reload = launch && answer.required;
+	if (answer.bundleId === next && !reload) return { kind: "none" };
+	return {
+		kind: "take",
+		bundleId: answer.bundleId,
+		download: answer.bundleId !== next,
+		reload
+	};
+};
+//#endregion
+export { swapDecision };

package/dist/app/native-auth-fetch.d.ts

@@ -5,5 +5,7 @@ export type NativeBridge = {
   getPlatform(): string;
   isPluginAvailable(name: string): boolean;
   nativePromise(plugin: string, method: string, options: object): Promise<unknown>;
+  /** What a plugin's call rejects with. */
+  Exception?: abstract new (...args: never[]) => Error;
 };
 //#endregion

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.57.3";
+var version = "0.57.4";
 var protobase = { "pluginApi": 1 };
 //#endregion
 export { protobase, version };