camox 0.43.0 → 0.45.0

package/dist/lib/use-thread.js

@@ -0,0 +1,310 @@
+import { apiSocketOptions } from "./api-socket.js";
+import { c } from "react/compiler-runtime";
+import * as React from "react";
+import { DEVELOPMENT_DRAFT } from "@camox/api-contract/drafts";
+import { usePartySocket } from "partysocket/react";
+import { EMPTY_THREAD_STATE, THREAD_ENDED_CLOSE_CODE, reduceThreadFrame, threadViewOf } from "@camox/api-contract/threads";
+
+//#region src/lib/use-thread.ts
+/** `WebSocket.OPEN`, without reaching for a global the server doesn't have. */
+const OPEN = 1;
+/**
+* Follows a thread in a project over its socket, folding Pi's events into the thread's view: the
+* signed-in editor's Live thread when `draftId` is null, or the draft's thread, which `draftId`
+* names as the draft header does (`development` in dev mode). A message is resent with its
+* operation id each time the thread shows itself after the socket opens, until it accepts it,
+* which records it once, or turns it down. A thread that ended with its draft isn't reconnected
+* to, but for a development draft's or the editor's Live thread, which move on to a new thread.
+* Mount it once per project and draft.
+*
+* When the Live thread starts a draft, a studio that sent a message of the run that wrote enters
+* the draft with it (`onEnterDraft`), even if it only hears so on reconnecting, from the editor's
+* fresh Live thread; its messages still on their way go with it. Any other studio moves on to
+* that fresh Live thread, continued in the draft.
+*
+* It reports what each writing script touched (`touched`), for runs one of its messages was part
+* of only, so that the studio follows the agent; teammates' runs leave it where it is. A studio
+* entering the draft its Live thread started keeps following that run there, starting with what
+* the write touched.
+*/
+function useThread(apiUrl, projectId, draftId, t0) {
+	const $ = c(47);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { carried, onEnterDraft } = t1;
+	const [state, setState] = React.useState(carried?.state ?? EMPTY_THREAD_STATE);
+	let t2;
+	if ($[2] !== state) {
+		t2 = threadViewOf(state);
+		$[2] = state;
+		$[3] = t2;
+	} else t2 = $[3];
+	const view = t2;
+	let t3;
+	if ($[4] !== carried?.unaccepted) {
+		t3 = carried?.unaccepted ?? /* @__PURE__ */ new Map();
+		$[4] = carried?.unaccepted;
+		$[5] = t3;
+	} else t3 = $[5];
+	const [unaccepted, setUnaccepted] = React.useState(t3);
+	const [error, setError] = React.useState();
+	const t4 = carried?.sent;
+	let t5;
+	if ($[6] !== t4) {
+		t5 = new Set(t4);
+		$[6] = t4;
+		$[7] = t5;
+	} else t5 = $[7];
+	const sent = React.useRef(t5);
+	const shown = React.useRef(false);
+	const [shows, setShows] = React.useState(0);
+	const [entering, setEntering] = React.useState();
+	const leaving = React.useRef(false);
+	let t6;
+	if ($[8] !== carried) {
+		t6 = () => carried?.touched ? {
+			sequence: 1,
+			batch: carried.touched
+		} : void 0;
+		$[8] = carried;
+		$[9] = t6;
+	} else t6 = $[9];
+	const [touched, setTouched] = React.useState(t6);
+	const touchedWhileLeaving = React.useRef(void 0);
+	let t7;
+	if ($[10] !== apiUrl) {
+		t7 = apiSocketOptions(apiUrl);
+		$[10] = apiUrl;
+		$[11] = t7;
+	} else t7 = $[11];
+	const socket = usePartySocket({
+		...t7,
+		basePath: draftId ? `threads/draft/${projectId}/${draftId}` : `threads/live/${projectId}`,
+		maxEnqueuedMessages: 0,
+		shouldReconnectOnClose: _temp,
+		onClose(event_0) {
+			const movesOn = draftId === null || draftId === DEVELOPMENT_DRAFT;
+			if (event_0.code === THREAD_ENDED_CLOSE_CODE && movesOn) socket.reconnect();
+		},
+		onOpen() {
+			shown.current = false;
+		},
+		onMessage(event_1) {
+			if (typeof event_1.data !== "string") return;
+			let frame;
+			try {
+				frame = JSON.parse(event_1.data);
+			} catch {
+				return;
+			}
+			onFrame(frame);
+		}
+	});
+	let t8;
+	if ($[12] !== draftId) {
+		t8 = (started) => draftId === null && started.operationIds.some((operationId) => sent.current.has(operationId));
+		$[12] = draftId;
+		$[13] = t8;
+	} else t8 = $[13];
+	const wrote = t8;
+	let t9;
+	if ($[14] === Symbol.for("react.memo_cache_sentinel")) {
+		t9 = (batch) => batch.operationIds.some((operationId_0) => sent.current.has(operationId_0));
+		$[14] = t9;
+	} else t9 = $[14];
+	const ours = t9;
+	const onFrame = React.useEffectEvent((frame_0) => {
+		if (leaving.current) {
+			if (frame_0.type === "touched" && ours(frame_0.touched)) touchedWhileLeaving.current = frame_0.touched;
+			return;
+		}
+		switch (frame_0.type) {
+			case "started-draft":
+			case "continued-in": {
+				const started_0 = frame_0.type === "started-draft" ? frame_0.startedDraft : frame_0.continuedIn;
+				if (wrote(started_0)) {
+					leaving.current = true;
+					setEntering(started_0.draftId);
+					return;
+				}
+				if (frame_0.type === "started-draft" && draftId === null) {
+					setState(EMPTY_THREAD_STATE);
+					socket.reconnect();
+					return;
+				}
+				setState((current_2) => reduceThreadFrame(current_2, frame_0));
+				return;
+			}
+			case "events":
+				setState((current_1) => reduceThreadFrame(current_1, frame_0));
+				if (!shown.current) {
+					shown.current = true;
+					setShows(_temp2);
+				}
+				return;
+			case "touched":
+				if (ours(frame_0.touched)) {
+					const batch_0 = frame_0.touched;
+					setTouched((last) => ({
+						sequence: (last?.sequence ?? 0) + 1,
+						batch: batch_0
+					}));
+				}
+				return;
+			case "accepted":
+				setUnaccepted((current_0) => without(current_0, frame_0.operationId));
+				return;
+			case "error": {
+				console.error("[useThread]", frame_0.message);
+				setError(frame_0.message);
+				const { operationId: operationId_1 } = frame_0;
+				if (operationId_1) setUnaccepted((current) => without(current, operationId_1));
+				return;
+			}
+		}
+	});
+	let t10;
+	if ($[15] !== socket || $[16] !== unaccepted) {
+		t10 = () => {
+			for (const [operationId_2, text] of unaccepted) transmit(socket, {
+				type: "send",
+				operationId: operationId_2,
+				text
+			});
+		};
+		$[15] = socket;
+		$[16] = unaccepted;
+		$[17] = t10;
+	} else t10 = $[17];
+	const resendUnaccepted = React.useEffectEvent(t10);
+	let t11;
+	if ($[18] !== resendUnaccepted || $[19] !== shows) {
+		t11 = () => {
+			if (shows > 0) resendUnaccepted();
+		};
+		$[18] = resendUnaccepted;
+		$[19] = shows;
+		$[20] = t11;
+	} else t11 = $[20];
+	let t12;
+	if ($[21] !== shows) {
+		t12 = [shows];
+		$[21] = shows;
+		$[22] = t12;
+	} else t12 = $[22];
+	React.useEffect(t11, t12);
+	let t13;
+	if ($[23] !== onEnterDraft || $[24] !== state || $[25] !== unaccepted) {
+		t13 = (started_1) => onEnterDraft?.(started_1, {
+			state,
+			unaccepted,
+			sent: sent.current,
+			touched: touchedWhileLeaving.current
+		});
+		$[23] = onEnterDraft;
+		$[24] = state;
+		$[25] = unaccepted;
+		$[26] = t13;
+	} else t13 = $[26];
+	const enterDraft = React.useEffectEvent(t13);
+	let t14;
+	if ($[27] !== enterDraft || $[28] !== entering) {
+		t14 = () => {
+			if (entering) enterDraft(entering);
+		};
+		$[27] = enterDraft;
+		$[28] = entering;
+		$[29] = t14;
+	} else t14 = $[29];
+	let t15;
+	if ($[30] !== entering) {
+		t15 = [entering];
+		$[30] = entering;
+		$[31] = t15;
+	} else t15 = $[31];
+	React.useEffect(t14, t15);
+	let t16;
+	if ($[32] !== socket) {
+		t16 = () => {
+			const resync = () => {
+				if (document.visibilityState === "visible") transmit(socket, { type: "resync" });
+			};
+			document.addEventListener("visibilitychange", resync);
+			return () => document.removeEventListener("visibilitychange", resync);
+		};
+		$[32] = socket;
+		$[33] = t16;
+	} else t16 = $[33];
+	let t17;
+	if ($[34] !== socket) {
+		t17 = [socket];
+		$[34] = socket;
+		$[35] = t17;
+	} else t17 = $[35];
+	React.useEffect(t16, t17);
+	let t18;
+	if ($[36] !== socket) {
+		t18 = (text_0) => {
+			const operationId_3 = crypto.randomUUID();
+			sent.current.add(operationId_3);
+			setError(void 0);
+			setUnaccepted((current_3) => new Map(current_3).set(operationId_3, text_0));
+			transmit(socket, {
+				type: "send",
+				operationId: operationId_3,
+				text: text_0
+			});
+		};
+		$[36] = socket;
+		$[37] = t18;
+	} else t18 = $[37];
+	const send = t18;
+	let t19;
+	if ($[38] !== socket) {
+		t19 = () => transmit(socket, { type: "stop" });
+		$[38] = socket;
+		$[39] = t19;
+	} else t19 = $[39];
+	const stop = t19;
+	const t20 = unaccepted.size > 0;
+	let t21;
+	if ($[40] !== error || $[41] !== send || $[42] !== stop || $[43] !== t20 || $[44] !== touched || $[45] !== view) {
+		t21 = {
+			view,
+			sending: t20,
+			send,
+			stop,
+			error,
+			touched
+		};
+		$[40] = error;
+		$[41] = send;
+		$[42] = stop;
+		$[43] = t20;
+		$[44] = touched;
+		$[45] = view;
+		$[46] = t21;
+	} else t21 = $[46];
+	return t21;
+}
+function _temp2(count) {
+	return count + 1;
+}
+function _temp(event) {
+	return event.code !== THREAD_ENDED_CLOSE_CODE;
+}
+function transmit(socket, message) {
+	if (socket.readyState === OPEN) socket.send(JSON.stringify(message));
+}
+const without = (map, key) => {
+	const next = new Map(map);
+	next.delete(key);
+	return next;
+};
+
+//#endregion
+export { useThread };

package/dist/lib/utils.js

@@ -26,11 +26,7 @@ function formatShortcut(shortcut) {
 	return /* @__PURE__ */ jsx(Shortcut, { shortcut });
 }
 function Shortcut(t0) {
-	const $ = c(15);
-	if ($[0] !== "45dff80dbc1805709c694dadbd04b0216f01c3a1a826daf47b8bb5bac9e42d9a") {
-		for (let $i = 0; $i < 15; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "45dff80dbc1805709c694dadbd04b0216f01c3a1a826daf47b8bb5bac9e42d9a";
-	}
+	const $ = c(14);
 	const { shortcut } = t0;
 	let t1;
 	bb0: {
@@ -63,16 +59,16 @@ function Shortcut(t0) {
 			break bb0;
 		}
 		let t2;
-		if ($[1] !== shortcut.key) {
+		if ($[0] !== shortcut.key) {
 			t2 = shortcut.key.toUpperCase();
-			$[1] = shortcut.key;
-			$[2] = t2;
-		} else t2 = $[2];
+			$[0] = shortcut.key;
+			$[1] = t2;
+		} else t2 = $[1];
 		t1 = t2;
 	}
 	const formattedKey = t1;
 	let t2;
-	if ($[3] !== formattedKey || $[4] !== shortcut.withAlt || $[5] !== shortcut.withMeta || $[6] !== shortcut.withShift) {
+	if ($[2] !== formattedKey || $[3] !== shortcut.withAlt || $[4] !== shortcut.withMeta || $[5] !== shortcut.withShift) {
 		t2 = (mac) => {
 			const modifiers = [];
 			if (shortcut.withMeta) modifiers.push(mac ? "⌘" : "Ctrl");
@@ -80,35 +76,35 @@ function Shortcut(t0) {
 			if (shortcut.withShift) modifiers.push(mac ? "⇧" : "Shift");
 			return `${modifiers.join()} ${formattedKey}`.trim();
 		};
-		$[3] = formattedKey;
-		$[4] = shortcut.withAlt;
-		$[5] = shortcut.withMeta;
-		$[6] = shortcut.withShift;
-		$[7] = t2;
-	} else t2 = $[7];
+		$[2] = formattedKey;
+		$[3] = shortcut.withAlt;
+		$[4] = shortcut.withMeta;
+		$[5] = shortcut.withShift;
+		$[6] = t2;
+	} else t2 = $[6];
 	const label = t2;
 	let t3;
-	if ($[8] !== label) {
+	if ($[7] !== label) {
 		t3 = label(true);
-		$[8] = label;
-		$[9] = t3;
-	} else t3 = $[9];
+		$[7] = label;
+		$[8] = t3;
+	} else t3 = $[8];
 	let t4;
-	if ($[10] !== label) {
+	if ($[9] !== label) {
 		t4 = label(false);
-		$[10] = label;
-		$[11] = t4;
-	} else t4 = $[11];
+		$[9] = label;
+		$[10] = t4;
+	} else t4 = $[10];
 	let t5;
-	if ($[12] !== t3 || $[13] !== t4) {
+	if ($[11] !== t3 || $[12] !== t4) {
 		t5 = /* @__PURE__ */ jsx(Kbd, { children: /* @__PURE__ */ jsx(PlatformLabel, {
 			mac: t3,
 			other: t4
 		}) });
-		$[12] = t3;
-		$[13] = t4;
-		$[14] = t5;
-	} else t5 = $[14];
+		$[11] = t3;
+		$[12] = t4;
+		$[13] = t5;
+	} else t5 = $[13];
 	return t5;
 }
 

package/dist/lib/view-locale-context.js

@@ -0,0 +1,22 @@
+import { UNNAMED_DEFAULT_LOCALE } from "./locale-path.js";
+import * as React from "react";
+
+//#region src/lib/view-locale-context.ts
+const ViewLocaleContext = React.createContext(null);
+/**
+* The page a render shows in every locale it exists in, as the page runtime found it. Null where
+* the render shows no page.
+*/
+const PageAlternatesContext = React.createContext(null);
+/** The view of a studio mounted outside the page runtime: the default locale alone. */
+const DEFAULT_VIEW = {
+	locale: UNNAMED_DEFAULT_LOCALE,
+	locales: [UNNAMED_DEFAULT_LOCALE]
+};
+/** The locale the studio views and the scope's locales: the default one outside the runtime. */
+function useViewLocale() {
+	return React.useContext(ViewLocaleContext) ?? DEFAULT_VIEW;
+}
+
+//#endregion
+export { PageAlternatesContext, ViewLocaleContext, useViewLocale };

package/dist/lib/view-locale.js

@@ -0,0 +1,46 @@
+import { localizedPath, parseLocalePath } from "./locale-path.js";
+import { useViewLocale } from "./view-locale-context.js";
+import { useLocation } from "../features/navigation/navigation.js";
+import { c } from "react/compiler-runtime";
+
+//#region src/lib/view-locale.tsx
+/**
+* The current location's path in the locale viewed, after its prefix (`/de/preise` is
+* `/preise`): what page paths, studio routes and the API's `path` inputs compare against.
+*/
+function useLocalePath() {
+	const $ = c(4);
+	const { locales } = useViewLocale();
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = { select: _temp };
+		$[0] = t0;
+	} else t0 = $[0];
+	const pathname = useLocation(t0);
+	let t1;
+	if ($[1] !== locales || $[2] !== pathname) {
+		t1 = parseLocalePath(pathname, locales);
+		$[1] = locales;
+		$[2] = pathname;
+		$[3] = t1;
+	} else t1 = $[3];
+	return t1.path;
+}
+function _temp(location) {
+	return location.pathname;
+}
+/** Builds a link to a locale-relative path in the locale viewed: `/preise` is `/de/preise`. */
+function useLocalizedPath() {
+	const $ = c(2);
+	const { locale } = useViewLocale();
+	let t0;
+	if ($[0] !== locale) {
+		t0 = (path) => localizedPath(path, locale);
+		$[0] = locale;
+		$[1] = t0;
+	} else t0 = $[1];
+	return t0;
+}
+
+//#endregion
+export { useLocalePath, useLocalizedPath };

package/dist/package.js

@@ -0,0 +1,5 @@
+//#region package.json
+var version = "0.45.0";
+
+//#endregion
+export { version };