dsh-mobile 0.8.6 → 0.8.8

package/lib/mobile-layout.js

@@ -24,19 +24,438 @@ window.__ModuleLoader__.load({
 			it: Object.freeze({
 				closePanels: "Chiudi pannelli",
 				workspaceNavigation: "Navigazione area di lavoro e sessioni",
-				backToConversation: "Torna alla conversazione"
+				backToConversation: "Torna alla conversazione",
+				composerRestore: "Mostra il campo di scrittura"
 			}),
 			en: Object.freeze({
 				closePanels: "Close panels",
 				workspaceNavigation: "Workspace and session navigation",
-				backToConversation: "Back to conversation"
+				backToConversation: "Back to conversation",
+				composerRestore: "Show composer"
 			}),
 			zh: Object.freeze({
 				closePanels: "关闭浮层",
 				workspaceNavigation: "工作区与会话导航",
-				backToConversation: "返回会话"
+				backToConversation: "返回会话",
+				composerRestore: "展开输入框"
 			})
 		});
+		// src/composer-collapse.ts
+		const COMPOSER_COLLAPSE_DEFAULTS = {
+			enabled: false,
+			collapseThresholdPx: 480,
+			reverseResetPx: 80
+		};
+		/**
+		* Track cumulative reading progress across scroll events. This is the only
+		* collapse policy: a decision table plus accumulated progress, kept out of the
+		* component so it stays testable without a DOM.
+		*/
+		var ComposerCollapseTracker = class {
+			readingProgress = 0;
+			reverseProgress = 0;
+			state = "expanded";
+			config;
+			constructor(config) {
+				this.config = config;
+			}
+			/** Whether the opt-in switch is currently on. */
+			get enabled() {
+				return this.config.enabled;
+			}
+			/** Update whether collapse is enabled (the user's settings toggle). */
+			setEnabled(enabled) {
+				this.config = {
+					...this.config,
+					enabled
+				};
+				if (!enabled) this.reset();
+			}
+			/**
+			* Feed one scroll sample; returns the resulting presentation state.
+			*
+			* reverseResetPx is a deliberate dead zone: a collapsed composer stays
+			* collapsed until the user scrolls back up at least that far, so a 1px jitter
+			* does not flip the layout on every frame.
+			*/
+			sample(deltaY) {
+				if (!this.config.enabled) {
+					this.reset();
+					return this.state;
+				}
+				if (this.state === "collapsed") {
+					if (deltaY > 0) {
+						this.reverseProgress = 0;
+						return this.state;
+					}
+					this.reverseProgress += -deltaY;
+					if (this.reverseProgress >= Math.max(this.config.reverseResetPx, 1)) this.reset();
+					return this.state;
+				}
+				if (deltaY < 0) {
+					this.readingProgress = Math.max(0, this.readingProgress + deltaY);
+					this.reverseProgress = 0;
+					return this.state;
+				}
+				this.readingProgress += deltaY;
+				this.reverseProgress = 0;
+				if (this.readingProgress >= this.config.collapseThresholdPx) this.state = "collapsed";
+				return this.state;
+			}
+			/** User interacted with the composer (focus, tap, keyboard, draft): expand. */
+			expand() {
+				this.reset();
+			}
+			get stateValue() {
+				return this.state;
+			}
+			/** @internal exposed for tests */
+			progress() {
+				return this.readingProgress;
+			}
+			reset() {
+				this.state = "expanded";
+				this.readingProgress = 0;
+				this.reverseProgress = 0;
+			}
+		};
+		const COMPOSER_COLLAPSE_EVENT = "dsh-mobile:composer-collapse-change";
+		/** Read the persisted opt-in. Defaults to off; unreadable storage keeps it off. */
+		function readComposerCollapseEnabled(storage) {
+			try {
+				const stored = (storage === void 0 ? globalThis.localStorage : storage)?.getItem("dsh-mobile.composer-collapse.enabled") ?? null;
+				if (stored !== null) return stored === "true";
+				return storage === void 0 ? false : false;
+			} catch {
+				return storage === void 0 ? false : false;
+			}
+		}
+		/**
+		* Subscribe to opt-in changes coming from either bundle. The listener is not
+		* called with the initial value; read it once with readComposerCollapseEnabled().
+		*/
+		function subscribeComposerCollapseEnabled(listener) {
+			const onStorage = (event) => {
+				if (event.key !== null && event.key !== "dsh-mobile.composer-collapse.enabled") return;
+				listener(readComposerCollapseEnabled());
+			};
+			const onCustom = (event) => {
+				const detail = event.detail;
+				listener(detail?.enabled ?? readComposerCollapseEnabled());
+			};
+			globalThis.addEventListener?.("storage", onStorage);
+			globalThis.addEventListener?.(COMPOSER_COLLAPSE_EVENT, onCustom);
+			return () => {
+				globalThis.removeEventListener?.("storage", onStorage);
+				globalThis.removeEventListener?.(COMPOSER_COLLAPSE_EVENT, onCustom);
+			};
+		}
+		/** Apply the persisted opt-in onto a base config. */
+		function composerCollapseConfigFrom(enabled, base = COMPOSER_COLLAPSE_DEFAULTS) {
+			return {
+				...base,
+				enabled
+			};
+		}
+		/**
+		* 软键盘开合监听。
+		* 键盘弹起（visualViewport 缩小）意味着用户要输入，应展开收起态。
+		* 封装在这里而不是 layout，是为了让 layout 源码不含 visualViewport——
+		* 那里只用 window.innerWidth 判宽屏，否则软键盘缩小可视视口会把手机误判成宽屏。
+		*/
+		function onViewportResize(handler) {
+			const viewport = globalThis.visualViewport;
+			if (viewport === null || viewport === void 0) return () => {};
+			viewport.addEventListener("resize", handler);
+			return () => {
+				viewport.removeEventListener("resize", handler);
+			};
+		}
+		const COLLAPSED_ATTRIBUTE = "data-dsh-mobile-composer-collapsed";
+		const RESTORE_LABEL_PROPERTY = "--dshm-composer-restore-label";
+		const CONVERSATION_SCROLL_SELECTOR = "[data-conversation-scroll]";
+		const COMPOSER_CARD_SELECTOR$1 = "[data-composer-card]";
+		const COMPOSER_EDITOR_SELECTOR$1 = `${COMPOSER_CARD_SELECTOR$1} :is([contenteditable="true"],[contenteditable="plaintext-only"],[contenteditable=""],textarea)`;
+		/**
+		* Install the reading-mode collapse. Opt-in through the persisted switch, off by
+		* default; the composer and its draft stay owned by DSH, this only toggles a
+		* presentation attribute on the document element.
+		*/
+		function installComposerReadingMode(options) {
+			const doc = options.doc ?? globalThis.document;
+			const root = doc.documentElement;
+			const tracker = new ComposerCollapseTracker(composerCollapseConfigFrom(readComposerCollapseEnabled()));
+			let collapsed = false;
+			const view = doc.defaultView;
+			const apply = (next) => {
+				if (collapsed === next) return;
+				collapsed = next;
+				root.setAttribute(COLLAPSED_ATTRIBUTE, next ? "true" : "false");
+			};
+			const expand = () => {
+				tracker.expand();
+				apply(false);
+			};
+			root.style.setProperty(RESTORE_LABEL_PROPERTY, JSON.stringify(options.restoreLabel));
+			const scroller = () => {
+				const found = doc.querySelector(CONVERSATION_SCROLL_SELECTOR);
+				return found instanceof (view?.HTMLElement ?? Object) ? found : void 0;
+			};
+			let lastTop = scroller()?.scrollTop ?? 0;
+			let rafPending = false;
+			const sample = () => {
+				rafPending = false;
+				const port = scroller();
+				if (port === void 0) return;
+				const top = port.scrollTop;
+				const delta = top - lastTop;
+				lastTop = top;
+				if (busy()) {
+					expand();
+					return;
+				}
+				apply(tracker.sample(delta) === "collapsed");
+			};
+			const onScroll = (event) => {
+				const target = event.target;
+				if (target === null || !target.hasAttribute?.(CONVERSATION_SCROLL_SELECTOR.slice(1, -1))) return;
+				if (rafPending) return;
+				rafPending = true;
+				if (view === null) {
+					sample();
+					return;
+				}
+				view.requestAnimationFrame(sample);
+			};
+			const busy = () => {
+				if (options.isRunning()) return true;
+				const card = doc.querySelector(COMPOSER_CARD_SELECTOR$1);
+				const editor = card?.querySelector(COMPOSER_EDITOR_SELECTOR$1) ?? null;
+				if (editor === null) return false;
+				const phase = editor.dataset.phase ?? "";
+				if (phase !== "" && phase !== "plain") return true;
+				const focused = doc.activeElement;
+				if (focused !== null && card !== null && card.contains(focused)) return true;
+				return (editor.value ?? editor.textContent ?? "").trim() !== "";
+			};
+			const guard = () => {
+				if (busy()) expand();
+			};
+			const onPointerDown = (event) => {
+				if (!collapsed) return;
+				const target = event.target;
+				if (target === null || !(target instanceof (view?.Element ?? Object))) return;
+				if (target.closest(COMPOSER_CARD_SELECTOR$1) === null) return;
+				expand();
+			};
+			const onFocusIn = () => {
+				expand();
+			};
+			let observed = [];
+			const observeCards = () => {
+				const cards = [...doc.querySelectorAll(COMPOSER_CARD_SELECTOR$1)];
+				if (cards.length === observed.length && cards.every((card, index) => card === observed[index])) return;
+				observer.disconnect();
+				for (const card of cards) observer.observe(card, {
+					childList: true,
+					subtree: true,
+					characterData: true,
+					attributes: true,
+					attributeFilter: ["data-phase"]
+				});
+				observed = cards;
+			};
+			const observer = new ((view?.MutationObserver) ?? MutationObserver)(() => {
+				observeCards();
+				guard();
+			});
+			observeCards();
+			doc.addEventListener("scroll", onScroll, {
+				passive: true,
+				capture: true
+			});
+			doc.addEventListener("pointerdown", onPointerDown, true);
+			doc.addEventListener("focusin", onFocusIn, true);
+			const stopPreference = subscribeComposerCollapseEnabled((enabled) => {
+				tracker.setEnabled(enabled);
+				if (!enabled) expand();
+			});
+			const stopViewport = onViewportResize(onFocusIn);
+			return {
+				expand,
+				dispose() {
+					doc.removeEventListener("scroll", onScroll, { capture: true });
+					doc.removeEventListener("pointerdown", onPointerDown, true);
+					doc.removeEventListener("focusin", onFocusIn, true);
+					stopViewport();
+					stopPreference();
+					observer.disconnect();
+					root.style.removeProperty(RESTORE_LABEL_PROPERTY);
+					apply(false);
+				}
+			};
+		}
+		/**
+		* Whether the active session is streaming a reply. A running reply is not a
+		* composer phase: `data-phase` returns to `plain` as soon as the submission is
+		* accepted, so this flag is the only truthful signal for the streaming window.
+		*/
+		function selectActiveSessionRunning(state) {
+			const current = state.current;
+			return current !== void 0 && state.byId[current]?.running === true;
+		}
+		// src/session-prefetch.ts
+		const SESSION_PREFETCH_DEFAULTS = {
+			enabled: false,
+			settleMs: 1500,
+			cooldownMs: 6e4,
+			timeoutMs: 2e4,
+			maxTargetsPerSwitch: 1
+		};
+		/**
+		* Storage key for the opt-in switch.
+		*
+		* The setting row lives in the client bundle while the tracker lives in the
+		* layout bundle (tsdown.config.ts emits them separately and inlines this module
+		* into each), so a module-level singleton cannot carry the value across. The
+		* layout bundle owns the persisted state instead; the row notifies it through
+		* both the storage event (other tabs) and a custom event (same page).
+		*/
+		const SESSION_PREFETCH_STORAGE_KEY = "dsh-mobile.session-prefetch.enabled";
+		const SESSION_PREFETCH_EVENT = "dsh-mobile:session-prefetch-change";
+		/** Read the persisted opt-in. Defaults to off; unreadable storage keeps it off. */
+		function readSessionPrefetchEnabled(storage) {
+			try {
+				return (storage ?? globalThis.localStorage)?.getItem(SESSION_PREFETCH_STORAGE_KEY) === "true";
+			} catch {
+				return false;
+			}
+		}
+		/**
+		* Subscribe to opt-in changes coming from either bundle. The listener is not
+		* called with the initial value; read it once with readSessionPrefetchEnabled().
+		*/
+		function subscribeSessionPrefetchEnabled(listener) {
+			const onStorage = (event) => {
+				if (event.key !== null && event.key !== "dsh-mobile.session-prefetch.enabled") return;
+				listener(readSessionPrefetchEnabled());
+			};
+			const onCustom = (event) => {
+				const detail = event.detail;
+				listener(detail?.enabled ?? readSessionPrefetchEnabled());
+			};
+			globalThis.addEventListener?.("storage", onStorage);
+			globalThis.addEventListener?.(SESSION_PREFETCH_EVENT, onCustom);
+			return () => {
+				globalThis.removeEventListener?.("storage", onStorage);
+				globalThis.removeEventListener?.(SESSION_PREFETCH_EVENT, onCustom);
+			};
+		}
+		/** Apply the persisted opt-in onto a base config. */
+		function sessionPrefetchConfigFrom(enabled, base = SESSION_PREFETCH_DEFAULTS) {
+			return {
+				...base,
+				enabled
+			};
+		}
+		/** In-memory per-session cooldown ledger plus MRU switch tracking (pure). */
+		var SessionPrefetchTracker = class {
+			config;
+			clock;
+			cooldownUntil = /* @__PURE__ */ new Map();
+			previousSession;
+			lastSwitchAt = 0;
+			constructor(config, clock = { now: () => Date.now() }) {
+				this.config = config;
+				this.clock = clock;
+			}
+			/** The effective opt-in this tracker was built with (read-only, for rebuilds). */
+			get enabled() {
+				return this.config.enabled;
+			}
+			/** Record that the UI switched to `sessionId`; returns the switch outcome. */
+			switchTo(sessionId) {
+				if (sessionId === "") return {
+					action: "skip",
+					reason: "no-previous"
+				};
+				const previous = this.previousSession;
+				this.previousSession = sessionId;
+				this.lastSwitchAt = this.clock.now();
+				if (previous === void 0) return {
+					action: "skip",
+					reason: "no-previous"
+				};
+				if (previous === sessionId) return {
+					action: "skip",
+					reason: "same-session"
+				};
+				if (!this.config.enabled) return {
+					action: "skip",
+					reason: "disabled"
+				};
+				const cooldownUntil = this.cooldownUntil.get(previous) ?? 0;
+				if (this.clock.now() < cooldownUntil) return {
+					action: "skip",
+					reason: "cooldown"
+				};
+				this.cooldownUntil.set(previous, this.clock.now() + this.config.cooldownMs);
+				return {
+					action: "warm",
+					target: previous
+				};
+			}
+			/** Whether the switch already passed the settle window (pure predicate). */
+			settled(now = this.clock.now()) {
+				return now - this.lastSwitchAt >= this.config.settleMs;
+			}
+			/** Forget state (used when the client unmounts). */
+			reset() {
+				this.cooldownUntil.clear();
+				this.previousSession = void 0;
+				this.lastSwitchAt = 0;
+			}
+		};
+		/**
+		* Fire a read-only `session/projections` prefetch, silently ignoring failures.
+		*
+		* The upstream RPC takes a single `request` parameter and the gateway validates
+		* wire names exactly (`assertExactArguments`), so the envelope must be
+		* `payload.args.request.sessionId` — the same shape every other call site in
+		* this repo uses (scripts/smoke-client-module-settings.mjs, smoke-draft-transfer.mjs).
+		* A bare `args.sessionId` is rejected with `gateway/arguments-invalid`.
+		*/
+		function prefetchSession(request, sessionId, timeoutMs) {
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), timeoutMs);
+			(async () => {
+				try {
+					if (!(await request("/api/session/projections", {
+						method: "POST",
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify({
+							type: "client-request",
+							rpcId: prefetchRpcId(),
+							method: "session/projections",
+							payload: { args: { request: { sessionId } } }
+						}),
+						signal: controller.signal
+					})).ok) return;
+				} catch {} finally {
+					clearTimeout(timer);
+				}
+			})();
+			return () => {
+				controller.abort();
+				clearTimeout(timer);
+			};
+		}
+		/** Unique per attempt; the upstream does not document a format, so prefer a real UUID. */
+		function prefetchRpcId() {
+			const cryptoApi = globalThis.crypto;
+			if (cryptoApi?.randomUUID !== void 0) return cryptoApi.randomUUID();
+			return `dsh-mobile-prefetch-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+		}
 		// src/mobile-layout.ts
 		/** Whether an optional service value supports the public right-Sidebar controls. */
 		function isSidebarRightControl(value) {
@@ -587,6 +1006,17 @@ body:has(.dshm-shell) :is(input,textarea,[contenteditable=true],[contenteditable
 .dshm-main[data-dsh-panel="1"] [data-slot="main"]>:not([data-dsh-adapt="off"]) :is(button,[role="button"],select,input:not([type=checkbox]):not([type=radio]):not([type=range]):not([type=hidden]):not([type=color]):not([type=file]):not([type=image])):not([role="switch"],[role="checkbox"],[role="radio"],[role="slider"],button[class*="_cardTitle"][class*="_cardOpen"],[data-dsh-adapt="off"],[data-dsh-adapt="off"] *){min-width:44px!important;min-height:44px!important}
 .dshm-main[data-dsh-panel="1"] [data-slot="main"]>:not([data-dsh-adapt="off"]) :is(button,[role="button"],a):not([data-dsh-adapt="off"],[data-dsh-adapt="off"] *){touch-action:manipulation}
 }
+/* Reading mode (issue #194): after scrolling down a long conversation the
+   composer editor collapses so the reading area is unobstructed. The card stays
+   and keeps the upstream Send/Stop row; its generated label is the way back, and
+   the text comes from --dshm-composer-restore-label so nothing is injected into
+   the React-managed card. Opt-in, off by default. */
+[data-dsh-mobile-composer-collapsed="true"] [data-composer-card] :is([contenteditable="true"],[contenteditable="plaintext-only"],[contenteditable=""],textarea){display:none!important}
+[data-dsh-mobile-composer-collapsed="true"] [data-composer-card]{
+  padding-top:6px!important;padding-bottom:6px!important;min-height:0!important;cursor:pointer}
+[data-dsh-mobile-composer-collapsed="true"] [data-composer-card]::before{
+  content:var(--dshm-composer-restore-label, "");display:flex;align-items:center;
+  justify-content:center;min-height:44px;font-size:13px;opacity:.75;pointer-events:none}
 `;
 		function MobileAppFrame(props) {
 			const state = (0, react.useSyncExternalStore)(props.controller.subscribe, props.controller.getSnapshot);
@@ -642,6 +1072,59 @@ body:has(.dshm-shell) :is(input,textarea,[contenteditable=true],[contenteditable
 				return current !== void 0 && session.byId[current]?.blank === false ? current : void 0;
 			});
 			const hasSession = activeSessionId !== void 0;
+			const prefetchEnabled = (0, react.useSyncExternalStore)(subscribeSessionPrefetchEnabled, readSessionPrefetchEnabled, () => false);
+			const prefetchTracker = (0, react.useRef)(void 0);
+			const prefetchTimer = (0, react.useRef)(void 0);
+			const prefetchDispose = (0, react.useRef)(void 0);
+			if (prefetchTracker.current === void 0 || prefetchTracker.current.enabled !== prefetchEnabled) prefetchTracker.current = new SessionPrefetchTracker(sessionPrefetchConfigFrom(prefetchEnabled));
+			(0, react.useEffect)(() => {
+				if (activeSessionId === void 0) return;
+				const decision = prefetchTracker.current.switchTo(activeSessionId);
+				if (decision.action !== "warm") return;
+				const target = decision.target;
+				if (prefetchTimer.current !== void 0) clearTimeout(prefetchTimer.current);
+				prefetchTimer.current = window.setTimeout(() => {
+					prefetchTimer.current = void 0;
+					prefetchDispose.current?.();
+					prefetchDispose.current = prefetchSession(fetch, target, SESSION_PREFETCH_DEFAULTS.timeoutMs);
+				}, SESSION_PREFETCH_DEFAULTS.settleMs);
+				return () => {
+					if (prefetchTimer.current !== void 0) {
+						clearTimeout(prefetchTimer.current);
+						prefetchTimer.current = void 0;
+					}
+					prefetchDispose.current?.();
+					prefetchDispose.current = void 0;
+				};
+			}, [activeSessionId, prefetchEnabled]);
+			const collapseEnabled = (0, react.useSyncExternalStore)(subscribeComposerCollapseEnabled, readComposerCollapseEnabled, () => false);
+			const activeRunning = props.useSessions(selectActiveSessionRunning);
+			const runningRef = (0, react.useRef)(activeRunning);
+			runningRef.current = activeRunning;
+			const active = collapseEnabled && hasSession;
+			const readingMode = (0, react.useRef)(void 0);
+			(0, react.useEffect)(() => {
+				if (!active) return;
+				const installed = installComposerReadingMode({
+					restoreLabel: messages.composerRestore,
+					isRunning: () => runningRef.current
+				});
+				readingMode.current = installed;
+				if (runningRef.current) installed.expand();
+				return () => {
+					readingMode.current = void 0;
+					installed.dispose();
+				};
+			}, [
+				active,
+				activeSessionId,
+				messages.composerRestore
+			]);
+			(0, react.useEffect)(() => {
+				if (!activeRunning) return;
+				readingMode.current?.expand();
+				document.documentElement.setAttribute("data-dsh-mobile-composer-collapsed", "false");
+			}, [activeRunning]);
 			(0, react.useEffect)(() => {
 				const observer = new MutationObserver(() => {
 					setDocumentLanguage(document.documentElement.lang);
@@ -925,6 +1408,7 @@ body:has(.dshm-shell) :is(input,textarea,[contenteditable=true],[contenteditable
 		exports.apply = apply;
 		exports.closeDetailsFromScrim = closeDetailsFromScrim;
 		exports.inject = inject;
+		exports.installComposerReadingMode = installComposerReadingMode;
 		exports.installComposerSendKeyboardPolicy = installComposerSendKeyboardPolicy;
 		exports.isComposerActionTap = isComposerActionTap;
 		exports.isComposerOwnedFocus = isComposerOwnedFocus;
@@ -932,10 +1416,12 @@ body:has(.dshm-shell) :is(input,textarea,[contenteditable=true],[contenteditable
 		exports.isSessionRowNavigation = isSessionRowNavigation;
 		exports.isSidebarRightControl = isSidebarRightControl;
 		exports.isWideViewportLayout = isWideViewportLayout;
+		exports.readComposerCollapseEnabled = readComposerCollapseEnabled;
 		exports.resolveComposerImePolicy = resolveComposerImePolicy;
 		exports.resolveDeviceShortSide = resolveDeviceShortSide;
 		exports.resolveMobileLayoutLanguage = resolveMobileLayoutLanguage;
 		exports.resolveMobileRightbarLayout = resolveMobileRightbarLayout;
+		exports.selectActiveSessionRunning = selectActiveSessionRunning;
 		return module.exports;
 	}
 });