84e136436c
The layout item's work plus the two defects its review found:
- the wide grid sized the list track from its MAX, so at 600-759px the detail pane
was clipped to 40-199px; cap the list below 900px and narrow the rail there
(measured now: detail 232px at 600, 332 at 700, 340 at 900, 880 at 1440);
- the shell said 'Not connected' on a fresh page because the prefilled proxy URL
validated; the status now reflects a SAVED endpoint ('Not configured' until then)
and refreshes as the draft changes.
Includes the rail + bottom dock, connection moved into Settings, viewport-only
scrolling with panes that scroll themselves, tab semantics, skip link, h1 per
route, and the design tokens.
413 lines
14 KiB
JavaScript
413 lines
14 KiB
JavaScript
// The Settings destination: Connection, Workspace, Notifications and the
|
|
// Templates card. Every string and validation rule comes from settings.js /
|
|
// notify.js; this module owns the DOM, the local drafts and the shared client's
|
|
// connection controls.
|
|
|
|
import { h } from "../dom.js";
|
|
import {
|
|
SERVER_URL_HELPER,
|
|
SERVER_URL_PLACEHOLDER,
|
|
TEMPLATES_CARD_LABEL,
|
|
TEMPLATES_CARD_SECONDARY,
|
|
TRUST_BODY,
|
|
TRUST_TITLE,
|
|
WORKSPACE_HELPER,
|
|
WORKSPACE_PLACEHOLDER,
|
|
canSaveWorkspace,
|
|
connectionActionKind,
|
|
connectionActions,
|
|
connectionCard,
|
|
savedWorkspaceLine,
|
|
workspaceErrorText,
|
|
writeWorkspace,
|
|
} from "../settings.js";
|
|
import {
|
|
NOTIFICATION_RATIONALE,
|
|
notificationEnvironment,
|
|
notificationPermissionState,
|
|
} from "../notify.js";
|
|
import { bannerState, protocolMismatch } from "../connection.js";
|
|
import { PROTOCOL_VERSION } from "../protocol.js";
|
|
|
|
export function createSettingsView(rt) {
|
|
const { state, repo, setServerUrlDraft, endpointConfigured } = rt;
|
|
const renderContent = (...args) => rt.renderContent(...args);
|
|
const pushRoute = (...args) => rt.pushRoute(...args);
|
|
const applyRoute = (...args) => rt.applyRoute(...args);
|
|
const openConfiguredEndpoint = (...args) => rt.openConfiguredEndpoint(...args);
|
|
const onReconnectClicked = (...args) => rt.onReconnectClicked(...args);
|
|
const persistNotifyAsked = (...args) => rt.views.attention.persistNotifyAsked(...args);
|
|
|
|
/**
|
|
* The Settings destination: the app's three sections (Connection, Workspace,
|
|
* Templates) in one pane. It is wiring only — every string, the workspace
|
|
* validation and the connection card's lines come from the pure `settings.js`,
|
|
* and the connection controls drive the page's existing single client through
|
|
* the same handlers the header uses (no second socket or path). Every
|
|
* server-derived string is set with textContent.
|
|
*/
|
|
function renderSettingsView() {
|
|
const pane = h("div", { class: "settings" });
|
|
pane.append(
|
|
h("h1", { class: "settings-page-title", id: "detailTitle", tabindex: "-1", text: "Settings" }),
|
|
renderSettingsConnection(),
|
|
renderSettingsWorkspace(),
|
|
renderSettingsNotifications(),
|
|
renderSettingsTemplates(),
|
|
);
|
|
return pane;
|
|
}
|
|
|
|
function renderSettingsConnection() {
|
|
const section = h("section", { class: "settings-section" });
|
|
section.append(h("h2", { class: "settings-title", text: "Connection" }));
|
|
|
|
section.append(
|
|
h(
|
|
"label",
|
|
{ class: "settings-field", for: "settingsServerUrl" },
|
|
h("span", { class: "settings-field-label", text: "Server URL" }),
|
|
h("input", {
|
|
id: "settingsServerUrl",
|
|
type: "text",
|
|
placeholder: SERVER_URL_PLACEHOLDER,
|
|
value: state.url,
|
|
spellcheck: "false",
|
|
autocomplete: "off",
|
|
"aria-describedby": "settingsUrlHelper",
|
|
"aria-invalid": state.urlError ? "true" : null,
|
|
oninput: (event) => {
|
|
setServerUrlDraft(event.target.value, "settingsServerUrl");
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
// Android's `urlError ?: helper` supporting text. The error clears on the next
|
|
// edit (AppViewModel.updateServerUrlDraft) and is announced as the field's own
|
|
// invalid state rather than as a page-level banner.
|
|
section.append(
|
|
h(
|
|
"p",
|
|
{
|
|
id: "settingsUrlHelper",
|
|
class: `settings-helper${state.urlError ? " settings-helper-error" : ""}`,
|
|
role: state.urlError ? "alert" : null,
|
|
},
|
|
serverUrlSupportingText(),
|
|
),
|
|
);
|
|
|
|
const actions = connectionActions(state.connection);
|
|
section.append(
|
|
h(
|
|
"div",
|
|
{ class: "settings-actions" },
|
|
h("button", {
|
|
id: "settingsPrimary",
|
|
class: "primary",
|
|
type: "button",
|
|
text: actions.primary,
|
|
onclick: () => runConnectionAction(actions.primary),
|
|
}),
|
|
h("button", {
|
|
id: "settingsSecondary",
|
|
class: "ghost",
|
|
type: "button",
|
|
text: actions.secondary,
|
|
onclick: () => runConnectionAction(actions.secondary),
|
|
}),
|
|
),
|
|
);
|
|
|
|
const tone = bannerState(state.connection, { hasEndpoint: endpointConfigured() }).tone;
|
|
const card = h("div", { class: `settings-status status-${tone}` });
|
|
const lines = connectionCard(state.connection, {
|
|
version: state.serverBuild?.version,
|
|
commit: state.serverBuild?.commit,
|
|
serverTime: state.serverTime,
|
|
});
|
|
lines.forEach((line, index) => {
|
|
// Android's Connecting card leads its one line with a CircularProgressIndicator;
|
|
// the shared spinner is drawn only for that state, inline with the text, so the
|
|
// other three stay plain text.
|
|
if (index === 0 && state.connection.kind === "connecting") {
|
|
const row = h("div", { class: "settings-status-head" });
|
|
row.append(h("span", { class: "spinner settings-status-spinner", "aria-hidden": "true" }));
|
|
row.append(h("p", { class: "settings-status-line", text: line }));
|
|
card.append(row);
|
|
return;
|
|
}
|
|
card.append(h("p", { class: "settings-status-line", text: line }));
|
|
});
|
|
section.append(card, renderTrustWarning());
|
|
const warning = protocolMismatch(PROTOCOL_VERSION, state.serverProtocol);
|
|
if (warning) {
|
|
section.append(
|
|
h("p", { class: "settings-warning-line settings-protocol-warning", role: "alert", text: warning }),
|
|
);
|
|
}
|
|
return section;
|
|
}
|
|
|
|
/**
|
|
* The Notifications section (L5). The Android rationale is shown verbatim; the
|
|
* status line is the pure permission view for this page's real browser facts.
|
|
* Only the explicit control asks for permission, never page load. When the API
|
|
* is unavailable, the page is insecure or permission is denied, the wording says
|
|
* plainly that the in-app Needs you surface is the only channel — no fake
|
|
* notification is ever drawn.
|
|
*/
|
|
function renderSettingsNotifications() {
|
|
const view = notificationPermissionState({
|
|
...notificationEnvironment(),
|
|
asked: state.notifyAsked,
|
|
});
|
|
const section = h("section", { class: "settings-section", id: "settingsNotifications" });
|
|
section.append(h("h2", { class: "settings-title", text: "Notifications" }));
|
|
section.append(h("p", { class: "settings-helper", text: NOTIFICATION_RATIONALE }));
|
|
section.append(
|
|
h("p", {
|
|
id: "settingsNotificationState",
|
|
class: `settings-notify-state settings-notify-${view.state}`,
|
|
role: "status",
|
|
text: view.body,
|
|
}),
|
|
);
|
|
if (view.canRequest) {
|
|
section.append(
|
|
h(
|
|
"div",
|
|
{ class: "settings-actions" },
|
|
h("button", {
|
|
id: "settingsEnableNotifications",
|
|
class: "primary",
|
|
type: "button",
|
|
text: view.actionLabel,
|
|
onclick: requestNotifications,
|
|
}),
|
|
),
|
|
);
|
|
}
|
|
return section;
|
|
}
|
|
|
|
/**
|
|
* Ask for notification permission from the operator's explicit click. The asked
|
|
* flag is persisted first and the page re-renders from the browser's real answer;
|
|
* a refused/dismissed prompt leaves the honest default/denied wording in place.
|
|
*/
|
|
function requestNotifications() {
|
|
persistNotifyAsked(true);
|
|
const ctor = globalThis.Notification;
|
|
if (typeof ctor !== "function" || !globalThis.isSecureContext) {
|
|
renderContent();
|
|
return;
|
|
}
|
|
try {
|
|
const result = ctor.requestPermission();
|
|
if (result && typeof result.then === "function") {
|
|
result.then(
|
|
() => renderContent(),
|
|
() => renderContent(),
|
|
);
|
|
return;
|
|
}
|
|
} catch {
|
|
// A browser that refuses the request keeps the honest fallback wording.
|
|
}
|
|
renderContent();
|
|
}
|
|
|
|
/** The trusted-network warning card, SettingsScreen.kt's TrustWarning verbatim. */
|
|
function renderTrustWarning() {
|
|
return h(
|
|
"div",
|
|
{ class: "settings-warning" },
|
|
h("p", { class: "settings-warning-title", text: TRUST_TITLE }),
|
|
h("p", { class: "settings-warning-body", text: TRUST_BODY }),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Route a Settings connection control through the page's existing single client,
|
|
* mirroring AppViewModel: Disconnect closes the shared socket, Connect is
|
|
* connect-only (validate + persist + open — never a toggle), and
|
|
* Reconnect re-opens the same validated endpoint now. Nothing here opens a second
|
|
* connection.
|
|
*/
|
|
function runConnectionAction(label) {
|
|
const kind = connectionActionKind(label);
|
|
if (kind === "disconnect") {
|
|
repo.disconnect();
|
|
return;
|
|
}
|
|
if (kind === "reconnect") {
|
|
onReconnectClicked();
|
|
return;
|
|
}
|
|
// The `Connect` label must never fall through to the header's toggle: while
|
|
// connected that would tear the live socket down (Android's connect() is
|
|
// connect-only).
|
|
openConfiguredEndpoint();
|
|
}
|
|
|
|
/** Android's `urlError ?: helper` supporting text for the Server URL field. */
|
|
function serverUrlSupportingText() {
|
|
return state.urlError || SERVER_URL_HELPER;
|
|
}
|
|
|
|
/**
|
|
* Update the Server URL field's own error state in place (supporting text,
|
|
* aria-invalid and the error tint) so an invalid Connect never needs a full
|
|
* re-render and the field being typed in is never rebuilt.
|
|
*/
|
|
function refreshServerUrlError() {
|
|
const field = document.getElementById("settingsServerUrl");
|
|
const helper = document.getElementById("settingsUrlHelper");
|
|
if (field) {
|
|
if (state.urlError) field.setAttribute("aria-invalid", "true");
|
|
else field.removeAttribute("aria-invalid");
|
|
}
|
|
if (helper) {
|
|
helper.textContent = serverUrlSupportingText();
|
|
helper.classList.toggle("settings-helper-error", Boolean(state.urlError));
|
|
if (state.urlError) helper.setAttribute("role", "alert");
|
|
else helper.removeAttribute("role");
|
|
}
|
|
}
|
|
|
|
function renderSettingsWorkspace() {
|
|
const section = h("section", { class: "settings-section" });
|
|
section.append(h("h2", { class: "settings-title", text: "Workspace" }));
|
|
section.append(
|
|
h(
|
|
"label",
|
|
{ class: "settings-field", for: "settingsWorkspace" },
|
|
h("span", { class: "settings-field-label", text: "Workspace path (on the server)" }),
|
|
h("input", {
|
|
id: "settingsWorkspace",
|
|
type: "text",
|
|
placeholder: WORKSPACE_PLACEHOLDER,
|
|
value: state.workspaceDraft,
|
|
spellcheck: "false",
|
|
autocomplete: "off",
|
|
"aria-describedby": "workspaceHelper",
|
|
"aria-invalid": workspaceErrorText(state.workspaceDraft) ? "true" : null,
|
|
oninput: (event) => {
|
|
state.workspaceDraft = event.target.value;
|
|
refreshWorkspaceControls();
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
section.append(
|
|
h(
|
|
"p",
|
|
{
|
|
id: "workspaceHelper",
|
|
class: `settings-helper${workspaceErrorText(state.workspaceDraft) ? " settings-helper-error" : ""}`,
|
|
},
|
|
workspaceSupportingText(),
|
|
),
|
|
);
|
|
section.append(
|
|
h("button", {
|
|
id: "saveWorkspace",
|
|
class: "primary settings-save",
|
|
type: "button",
|
|
text: "Save workspace",
|
|
disabled: !canSaveWorkspace(state.workspaceDraft),
|
|
onclick: saveWorkspace,
|
|
}),
|
|
);
|
|
section.append(h("p", { id: "savedWorkspace", class: "settings-saved", text: savedWorkspaceLine(state.workspace) }));
|
|
return section;
|
|
}
|
|
|
|
/** Android's `workspaceError ?: helper` supporting text for the workspace field. */
|
|
function workspaceSupportingText() {
|
|
return workspaceErrorText(state.workspaceDraft) || WORKSPACE_HELPER;
|
|
}
|
|
|
|
/**
|
|
* Update the workspace field's dependent controls in place (the helper/error line
|
|
* and the Save button's enabled state) so typing never re-renders — and so never
|
|
* blurs — the field being typed in.
|
|
*/
|
|
function refreshWorkspaceControls() {
|
|
const helper = document.getElementById("workspaceHelper");
|
|
const invalid = Boolean(workspaceErrorText(state.workspaceDraft));
|
|
if (helper) {
|
|
helper.textContent = workspaceSupportingText();
|
|
helper.classList.toggle("settings-helper-error", invalid);
|
|
}
|
|
const field = document.getElementById("settingsWorkspace");
|
|
if (field) {
|
|
if (invalid) field.setAttribute("aria-invalid", "true");
|
|
else field.removeAttribute("aria-invalid");
|
|
}
|
|
const save = document.getElementById("saveWorkspace");
|
|
if (save) save.disabled = !canSaveWorkspace(state.workspaceDraft);
|
|
}
|
|
|
|
/** Persist the workspace (trimmed) and update the `Saved workspace:` line. */
|
|
function saveWorkspace() {
|
|
if (!canSaveWorkspace(state.workspaceDraft)) return;
|
|
state.workspace = writeWorkspace(localStorage, state.workspaceDraft);
|
|
state.workspaceDraft = state.workspace;
|
|
// Show the trimmed value that was actually stored, in the field as well as the
|
|
// saved line (both updated in place so the keyboard focus is not disturbed).
|
|
const field = document.getElementById("settingsWorkspace");
|
|
if (field) field.value = state.workspace;
|
|
const saved = document.getElementById("savedWorkspace");
|
|
if (saved) saved.textContent = savedWorkspaceLine(state.workspace);
|
|
}
|
|
|
|
function openTemplatesFromSettings() {
|
|
const route = { kind: "templates" };
|
|
pushRoute(route);
|
|
applyRoute(route);
|
|
}
|
|
|
|
function renderSettingsTemplates() {
|
|
const section = h("section", { class: "settings-section" });
|
|
section.append(h("h2", { class: "settings-title", text: "Templates" }));
|
|
const card = h(
|
|
"button",
|
|
{
|
|
id: "browseTemplates",
|
|
class: "card settings-card",
|
|
type: "button",
|
|
onclick: openTemplatesFromSettings,
|
|
},
|
|
// SettingsScreen.kt's row idiom: a leading glyph, the label and secondary
|
|
// line, then a forward chevron.
|
|
h("span", { class: "settings-card-glyph", "aria-hidden": "true", text: "\u25a4" }),
|
|
h(
|
|
"span",
|
|
{ class: "settings-card-text" },
|
|
h("span", { class: "card-name", text: TEMPLATES_CARD_LABEL }),
|
|
h("span", { class: "card-desc", text: TEMPLATES_CARD_SECONDARY }),
|
|
),
|
|
h("span", { class: "settings-card-chevron", "aria-hidden": "true", text: "\u203a" }),
|
|
);
|
|
section.append(card);
|
|
return section;
|
|
}
|
|
|
|
return {
|
|
renderSettingsView,
|
|
renderSettingsConnection,
|
|
requestNotifications,
|
|
runConnectionAction,
|
|
serverUrlSupportingText,
|
|
refreshServerUrlError,
|
|
renderSettingsWorkspace,
|
|
workspaceSupportingText,
|
|
refreshWorkspaceControls,
|
|
saveWorkspace,
|
|
openTemplatesFromSettings,
|
|
renderSettingsTemplates,
|
|
};
|
|
}
|