better-dsh 0.0.0 → 0.2.2-a

package/lib/client/index.js

@@ -0,0 +1,473 @@
+window.__ModuleLoader__.load({ id: "better-dsh", factory: (require) => {
+var module = { exports: {} }; var exports = module.exports;
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let react = require("react");
+react = __toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+react_jsx_runtime = __toESM(react_jsx_runtime);
+
+//#region src/failover/config.ts
+/**
+* The `failover` general-fallback config (host-plane, per-turn latch).
+*
+* Pure module — no `@deepseek-ai/*` value imports, so both the host module and
+* the client half may import it (the client type-only) without dragging a host
+* runtime dependency into the browser bundle.
+*
+* A route is a `provider/model` string (e.g. `deepseek/deepseek-v4-flash`).
+* The empty string `''` means "not set" — the slot is skipped.
+*
+* @module dashr/failover/config
+*/
+/** The settings namespace the General row reads and writes. */
+const FAILOVER_SETTINGS_NS = "failover";
+
+//#endregion
+//#region src/failover/client/locales.ts
+/**
+* Client locale dictionary for the failover General row.
+* @module dashr/failover/client/locales
+*/
+const NS = "failover";
+const en = {
+	"title": "Model failover",
+	"fallback1": "Fallback 1",
+	"fallback2": "Fallback 2",
+	"not-set": "— not set —",
+	"loading": "Loading…",
+	"error": "Save failed: {{message}}"
+};
+const zh = {
+	"title": "模型故障转移",
+	"fallback1": "备用模型 1",
+	"fallback2": "备用模型 2",
+	"not-set": "— 不设置 —",
+	"loading": "加载中…",
+	"error": "保存失败：{{message}}"
+};
+
+//#endregion
+//#region \0dsh-css:/home/u1/workspaces/dashr/dashr/src/failover/client/FailoverRow.module.css.mjs
+const css = "._440e1d7b_row {\n  display: flex;\n  flex-direction: column;\n  gap: 8px;\n  padding: 12px 0;\n}\n\n._9865b509_title {\n  font-weight: 600;\n  font-size: 14px;\n}\n\n._3cfec826_slots {\n  display: flex;\n  flex-direction: column;\n  gap: 6px;\n}\n\n._70954771_slot {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n}\n\n._ba1fd839_slotLabel {\n  min-width: 88px;\n  flex-shrink: 0;\n  font-size: 13px;\n  color: var(--dsw-alias-text-secondary, #666);\n}\n\n._11c2662d_select {\n  flex: 1;\n  max-width: 280px;\n  min-width: 0;\n}\n\n._b7c358f9_alert {\n  color: var(--dsw-alias-danger, #c0392b);\n  font-size: 12px;\n}\n";
+const tagId = "better-dsh/FailoverRow.module.css";
+if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {
+	const tag = document.createElement("style");
+	tag.dataset.plugin = "better-dsh";
+	tag.dataset.pluginCss = tagId;
+	tag.textContent = css;
+	document.head.appendChild(tag);
+}
+var FailoverRow_module_css_default = {
+	"row": "_440e1d7b_row",
+	"title": "_9865b509_title",
+	"slots": "_3cfec826_slots",
+	"slot": "_70954771_slot",
+	"slotLabel": "_ba1fd839_slotLabel",
+	"select": "_11c2662d_select",
+	"alert": "_b7c358f9_alert"
+};
+
+//#endregion
+//#region src/failover/client/FailoverRow.tsx
+/** Render the failover row: title + two model selectors. */
+function FailoverRow({ catalog, loadConfig, save, t }) {
+	const [loaded, setLoaded] = (0, react.useState)(null);
+	const [error, setError] = (0, react.useState)(null);
+	const [saving, setSaving] = (0, react.useState)(false);
+	(0, react.useEffect)(() => {
+		let alive = true;
+		(async () => {
+			try {
+				const [routes$1, cfg] = await Promise.all([catalog(), loadConfig()]);
+				if (!alive) return;
+				setLoaded({
+					routes: routes$1,
+					config: cfg ?? {
+						fallback1: "",
+						fallback2: ""
+					},
+					revision: cfg?.revision
+				});
+			} catch (err) {
+				if (alive) setError(err instanceof Error ? err.message : String(err));
+			}
+		})();
+		return () => {
+			alive = false;
+		};
+	}, [catalog, loadConfig]);
+	const select = async (slot, value) => {
+		if (loaded === null || saving) return;
+		setSaving(true);
+		setError(null);
+		try {
+			const nextRevision = await save({ [slot]: value }, loaded.revision);
+			setLoaded({
+				...loaded,
+				config: {
+					...loaded.config,
+					[slot]: value
+				},
+				revision: nextRevision
+			});
+		} catch (err) {
+			setError(err instanceof Error ? err.message : String(err));
+		} finally {
+			setSaving(false);
+		}
+	};
+	const routes = loaded?.routes ?? [];
+	const renderSelect = (slot, label) => {
+		const value = loaded?.config[slot] ?? "";
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			className: FailoverRow_module_css_default.slot,
+			children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				className: FailoverRow_module_css_default.slotLabel,
+				children: label
+			}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
+				className: FailoverRow_module_css_default.select,
+				value,
+				disabled: saving || loaded === null,
+				onChange: (event) => {
+					select(slot, event.target.value);
+				},
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+					value: "",
+					children: t("not-set")
+				}), routes.map((route) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+					value: route,
+					children: route
+				}, route))]
+			})]
+		});
+	};
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+		className: FailoverRow_module_css_default.row,
+		children: [
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: FailoverRow_module_css_default.title,
+				children: t("title")
+			}),
+			error !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: FailoverRow_module_css_default.alert,
+				role: "alert",
+				children: t("error", { message: error })
+			}) : null,
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: FailoverRow_module_css_default.slots,
+				children: [renderSelect("fallback1", t("fallback1")), renderSelect("fallback2", t("fallback2"))]
+			})
+		]
+	});
+}
+
+//#endregion
+//#region src/mobile/gesture.ts
+/**
+* Resolved defaults — the `1706b81` constants (120 / viewport÷4 / 40 / 1.3 /
+* 768) plus the one addition, the velocity gate. A slow text-selection drag
+* runs ~0.13 px/ms; 0.15 px/ms filters those while any comfortable sweep
+* (0.4 px/ms and up) passes.
+*/
+const DEFAULT_SWIPE_THRESHOLDS = {
+	breakpoint: 768,
+	swipeDistancePx: 40,
+	dominanceRatio: 1.3,
+	leftEdgeBandPx: 120,
+	rightZoneRatio: .25,
+	swipeVelocityPxPerMs: .15
+};
+/**
+* Whether one completed gesture's viewport is in the gesture band.
+*
+* @param viewportWidth - viewport width at gesture time (px).
+* @param thresholds - resolved recognition thresholds (`.breakpoint`).
+* @returns `true` when `viewportWidth` is strictly below the breakpoint.
+*/
+function isNarrowViewport(viewportWidth, thresholds) {
+	return viewportWidth < thresholds.breakpoint;
+}
+/**
+* Whether a pointerdown may START a gesture — the source's pointerdown
+* gate, verbatim: with both panels closed, only the left band (X120) or
+* the right three quarters of the screen admit; with a panel open, any
+* position admits (that swipe is a dismiss).
+*
+* @param x - pointerdown client X.
+* @param viewportWidth - viewport width at gesture time (px).
+* @param panels - panel state at pointerdown.
+* @param thresholds - resolved recognition thresholds.
+* @returns `true` when the origin is admitted into tracking.
+*/
+function admitsSwipeStart(x, viewportWidth, panels, thresholds) {
+	if (!(panels.leftCollapsed && !panels.rightOpen)) return true;
+	return x <= thresholds.leftEdgeBandPx || x >= viewportWidth * thresholds.rightZoneRatio;
+}
+/**
+* Classify one in-flight drag into a panel action — the source's
+* pointermove decision, verbatim, plus the velocity gate. Callers fire
+* ONCE (then drop the drag): a `null` here means "not yet / not this
+* gesture", and the same drag may classify on a LATER move event as its
+* displacement or velocity grows.
+*
+* @param progress - the drag's displacement and elapsed time so far.
+* @param panels - panel state read live at this event.
+* @param sessionLive - whether a session is current (gates opening the
+*   right panel, mirroring the source's `detailsSession !== undefined`).
+* @param thresholds - resolved recognition thresholds.
+* @returns the action the drag maps to, or `null` when no panel admits
+*   it yet.
+*/
+function classifySwipeProgress(progress, panels, sessionLive, thresholds) {
+	const adx = Math.abs(progress.dx);
+	const ady = Math.abs(progress.dy);
+	if (adx < thresholds.swipeDistancePx) return null;
+	if (adx <= ady * thresholds.dominanceRatio) return null;
+	if (thresholds.swipeVelocityPxPerMs > 0) {
+		if (progress.dtMs <= 0) return null;
+		if (adx / progress.dtMs < thresholds.swipeVelocityPxPerMs) return null;
+	}
+	if (progress.dx < 0) {
+		if (!panels.leftCollapsed) return "close-left";
+		if (sessionLive && !panels.rightOpen) return "open-right";
+		return null;
+	}
+	if (panels.rightOpen) return "close-right";
+	if (panels.leftCollapsed) return "open-left";
+	return null;
+}
+/**
+* Merge the host-injected page config over the defaults. An absent config
+* (host feature off, or an old cached page) resolves to enabled=false — the
+* client half is inert unless the host opted the page in.
+*
+* @param pageConfig - `window.__DASHR_MOBILE__` as left by the boot script.
+* @returns resolved thresholds plus the enable flag.
+*/
+function resolveMobileConfig(pageConfig) {
+	if (pageConfig === void 0 || pageConfig.enabled !== true) return {
+		enabled: false,
+		...DEFAULT_SWIPE_THRESHOLDS
+	};
+	const n = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+	const v = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+	return {
+		enabled: true,
+		breakpoint: n(pageConfig.breakpoint, DEFAULT_SWIPE_THRESHOLDS.breakpoint),
+		swipeDistancePx: n(pageConfig.swipeDistancePx, DEFAULT_SWIPE_THRESHOLDS.swipeDistancePx),
+		dominanceRatio: n(pageConfig.dominanceRatio, DEFAULT_SWIPE_THRESHOLDS.dominanceRatio),
+		leftEdgeBandPx: n(pageConfig.leftEdgeBandPx, DEFAULT_SWIPE_THRESHOLDS.leftEdgeBandPx),
+		rightZoneRatio: n(pageConfig.rightZoneRatio, DEFAULT_SWIPE_THRESHOLDS.rightZoneRatio),
+		swipeVelocityPxPerMs: v(pageConfig.swipeVelocityPxPerMs, DEFAULT_SWIPE_THRESHOLDS.swipeVelocityPxPerMs)
+	};
+}
+
+//#endregion
+//#region src/mobile/client/index.ts
+/** Left sidebar state, live off AppFrame's semantic attribute. */
+function readLeftCollapsed() {
+	return document.querySelector("[data-sidebar-collapsed]") !== null;
+}
+/**
+* Better Sidebar's right-panel state, live off the body attribute the
+* plugin itself publishes (collapsed = closed). Read SYNCHRONOUSLY in the
+* handlers — a cached mirror lags the panel's own DOM write by a render,
+* and a close-swipe issued right after an open-swipe would misroute.
+*/
+function readRightOpen() {
+	return !document.body.hasAttribute("data-dsh-sidebar-collapsed");
+}
+/**
+* Whether a session is current — the plugin-side stand-in for the source's
+* `detailsSession !== undefined` guard (the right panel opens in a session
+* only). Better Sidebar's own shipped CSS keys off the same slot selector,
+* so it is load-bearing beyond this feature.
+*/
+function readSessionLive() {
+	return document.querySelector("[data-slot=\"conversation.session.header\"]") !== null;
+}
+/** Panel state snapshot, both sources live. */
+function readPanelState() {
+	return {
+		leftCollapsed: readLeftCollapsed(),
+		rightOpen: readRightOpen()
+	};
+}
+/**
+* Toggle Better Sidebar's right panel through its persistent DOM: the
+* plugin exposes no JS toggle on its client service (its open/close
+* reducer is store-internal), so the swipe reaches it the same way the
+* source did — clicking the LAST button of its always-rendered
+* `[data-dsh-toggle-cluster]` (the bottom-panel button precedes it and is
+* absent below the plugin's 768px narrow breakpoint). Absent cluster or
+* buttons: a no-op, never a crash.
+*/
+function toggleBetterSidebar() {
+	const buttons = document.querySelector("[data-dsh-toggle-cluster]")?.querySelectorAll("button");
+	(buttons?.[buttons.length - 1])?.click();
+}
+/**
+* The narrow-viewport CSS: zero-width sidebar track under the breakpoint,
+* keyed to AppFrame's semantic attribute (survives class-hash churn).
+* Rendered with the breakpoint baked in (media queries cannot read JS
+* config); the tag carries the plugin-owned dataset so the loader's
+* style-claim machinery removes it on unload, like module CSS.
+*/
+function mobileCss(breakpointPx) {
+	const wide = Math.max(1, Math.floor(breakpointPx) - .02);
+	return [
+		`@media (max-width: ${String(wide)}px) {`,
+		`  [data-sidebar-collapsed] {`,
+		`    grid-template-columns: 0px minmax(0, 1fr) 0px !important;`,
+		`  }`,
+		`}`
+	].join("\n");
+}
+/**
+* Mount the mobile feature: style injection plus the swipe listeners.
+* Inert unless the host's boot script opted the page in.
+*
+* @param ctx - client root context.
+* @returns the effect disposer (style tag + listeners removed on unload).
+*/
+function setupMobileLayout(ctx) {
+	const pageConfig = globalThis.__DASHR_MOBILE__;
+	const config = resolveMobileConfig(pageConfig);
+	if (!config.enabled) return;
+	const styleTagId = "better-dsh/mobile";
+	ctx.effect(() => {
+		const tag = document.createElement("style");
+		tag.dataset.plugin = "better-dsh";
+		tag.dataset.pluginCss = styleTagId;
+		tag.textContent = mobileCss(config.breakpoint);
+		document.head.append(tag);
+		const offLayout = ctx.inject(["layout"], (layoutCtx) => {
+			const layout = layoutCtx.get("layout");
+			if (layout === void 0) return;
+			let start;
+			const onPointerDown = (event) => {
+				start = void 0;
+				const viewport = window.innerWidth;
+				if (!isNarrowViewport(viewport, config)) return;
+				if (!admitsSwipeStart(event.clientX, viewport, readPanelState(), config)) return;
+				start = {
+					x: event.clientX,
+					y: event.clientY,
+					t: event.timeStamp
+				};
+			};
+			const onPointerMove = (event) => {
+				const origin = start;
+				if (origin === void 0) return;
+				const action = classifySwipeProgress({
+					dx: event.clientX - origin.x,
+					dy: event.clientY - origin.y,
+					dtMs: event.timeStamp - origin.t
+				}, readPanelState(), readSessionLive(), config);
+				if (action === null) return;
+				start = void 0;
+				if (action === "open-left" || action === "close-left") layout.toggleSidebar();
+				else toggleBetterSidebar();
+			};
+			const onPointerEnd = () => {
+				start = void 0;
+			};
+			document.addEventListener("pointerdown", onPointerDown, true);
+			document.addEventListener("pointermove", onPointerMove, true);
+			document.addEventListener("pointerup", onPointerEnd, true);
+			document.addEventListener("pointercancel", onPointerEnd, true);
+			return () => {
+				document.removeEventListener("pointerdown", onPointerDown, true);
+				document.removeEventListener("pointermove", onPointerMove, true);
+				document.removeEventListener("pointerup", onPointerEnd, true);
+				document.removeEventListener("pointercancel", onPointerEnd, true);
+			};
+		});
+		return () => {
+			tag.remove();
+			Promise.resolve(offLayout.dispose());
+		};
+	}, "dashr: mobile layout");
+}
+
+//#endregion
+//#region src/failover/client/index.ts
+/** Required services (cordis fiber inject). */
+const inject = [
+	"slots",
+	"locale",
+	"remote",
+	"remote.settings",
+	"remote.session"
+];
+/**
+* Register the `failover` dictionaries and the General settings row.
+* @param ctx - client root context.
+*/
+function apply(ctx) {
+	ctx.effect(() => ctx.locale.register(NS, {
+		zh,
+		en
+	}), "llm-failover: dictionaries");
+	setupMobileLayout(ctx);
+	ctx.slots.inject("settings.general.item", function* () {
+		yield ctx.slots.register({
+			name: "settings.general.item",
+			id: "failover",
+			order: 100,
+			locale: NS,
+			inject: () => ({
+				catalog: async () => {
+					const response = await ctx.remote.session.modelCatalog();
+					if (!response.ok) throw new Error(`${response.error.code}: ${response.error.message}`);
+					return response.value.groups.flatMap((group) => group.models.map((model) => `${group.id}/${model.id}`));
+				},
+				loadConfig: async () => {
+					const response = await ctx.remote.settings.describe();
+					if (!response.ok) throw new Error(`${response.error.code}: ${response.error.message}`);
+					const view = response.value.namespaces.find((entry) => entry.ns === FAILOVER_SETTINGS_NS);
+					if (view === void 0) return null;
+					const value = view.value;
+					return {
+						fallback1: typeof value.fallback1 === "string" ? value.fallback1 : "",
+						fallback2: typeof value.fallback2 === "string" ? value.fallback2 : "",
+						revision: view.revision
+					};
+				},
+				save: async (patch, revision) => {
+					const response = await ctx.remote.settings.update(FAILOVER_SETTINGS_NS, patch, revision);
+					if (!response.ok) throw new Error(`${response.error.code}: ${response.error.message}`);
+					return response.value.revision;
+				}
+			})
+		}, FailoverRow);
+	});
+}
+
+//#endregion
+exports.FailoverRow = FailoverRow;
+exports.apply = apply;
+exports.inject = inject;
+return module.exports; } });