🔢 Expose file versions in the sidebar

[karlitschek]

Notes have been versioned all along — they are ordinary files, so files_versions keeps history for them without the app doing anything. There was just no way to see it from Notes. Exposing it turned the note sidebar into something worth bringing closer to the Files one, so this PR does both.

Most of the wiring already existed:

• PageController dispatches OCA\Files\Event\LoadSidebar, and files_versions registers a listener on that event which adds its sidebar-tab script. The Versions tab has therefore been registered on every Notes page already, simply never rendered.
• NotePlain and NoteRich both already subscribe to files_versions:restore:requested and :restored, showing a loading state and refreshing the note afterwards. The restore path was built and unreachable.
• NoteShareSidebar already knew how to mount a registered Files sidebar tab as a custom element with the node/folder/view props it expects.

The only thing missing was that the sidebar hard-filtered the tab registry down to id === 'sharing'. It now renders every tab from an allow-list, so Sharing and Versions sit side by side.

What else is in here

• Versions is reachable from the note's action menu, next to "Share". That menu lives in the note list row, so it is present in every editor mode.
• "Open sidebar" in the editor's own actions menu, using the DockRight icon and the label the Viewer app uses for the same entry. That menu only exists in the markdown editor — the rich editor brings its own menu bar — so the note list row remains the path that works in every mode.
• The sidebar header carries the file metadata: size, modification date, and the owner as a bubble with avatar and display name. This reimplements what the Files sidebar renders in its subname slot. No new data plumbing was needed — fetchDavNode() already uses the default propfind, which asks for getcontentlength, getlastmodified, owner-id and owner-display-name.
• The sharing tab icon is outlined until its tab is active, then fills. Versions keeps the icon its app registered, as there is no outlined counterpart of backup-restore, and both icons line up with each other.
• Restoring a version updates the app right away. The versions list refreshes in place instead of waiting for a reload, and the editor is replaced by a spinner while the restored content loads, so it cannot be typed into halfway through the switch.

Implementation notes

• Tab selection moved to a pure function in sidebarTabs.js. It is an allow-list rather than "everything registered", because LoadSidebar brings in whatever every installed app registers and a note sidebar should not grow new tabs when an unrelated app is installed. A tab's own enabled() predicate still has the final say — the versions tab hides itself on public shares and for non-files — but it needs a node to judge, so while the node is still loading tabs are kept and filtered again once it arrives. A predicate that throws drops that tab, with the failure logged, instead of taking the sidebar down.
• Tabs initialise independently, so one failing to define its custom element no longer hides the others. A tab whose element never got defined is not offered at all, rather than sitting in the tab bar with an empty pane behind it; it gets another chance on the next open.
• No tab is waited for indefinitely. customElements.whenDefined() never settles for an element that is never defined, so it is raced against a timeout — otherwise an onInit() that resolves without delivering its element would leave the sidebar spinning, with the pending initialization stuck for every later open as well.
• Opens that overlap share the in-flight initialization of a custom element instead of assuming it already succeeded.
• New event notes:sidebar:open carries a tab id. notes:share:open is kept as a thin wrapper so anything already emitting it keeps working.
• The requested tab is clamped to one the sidebar actually renders — NcAppSidebar falls back to its first tab on its own, but does not report that back.
• The icon swap happens inside the #icon slot rather than through a dedicated one, since @nextcloud/vue has no #icon-active: NcAppSidebarTab exposes renderIcon() without arguments. The tab button invokes it from its own render function, so reading the resolved tab id there tracks it.
• Mixing the two icon systems misaligns the tab bar: NcIconSvgWrapper reserves a clickable-area box around its svg, while a material design icon is only as big as itself, which put the versions icon 7px below the sharing one. The wrapper's inline modifier drops that box, leaving both at 20px — the same as the sidebar in 📊 Note details tab in the sidebar #1974.
• The versions tab reloads itself when the mtime of the node it was handed changes, and emits files:node:updated with a node carrying the restored etag, size and mtime. The sidebar answers that by swapping its current node, the way the Files sidebar store does, matching on source. The subname picks it up as well, so size and modification date do not lag behind a restore either.
• The restore handlers in both editors were reading a payload files_versions no longer emits — a fileInfo key, and a fileId on the version — so the requested one threw and the restored one always returned early. They take the node from the event now and compare its fileid, which brings back both the loading state and the immediate refresh. NotePlain.refreshNote() returns its promise so that loading state outlasts the refresh, and both editors clear it on files_versions:restore:failed rather than staying behind the spinner for good.
• Sidebar copy no longer says "sharing" now that it hosts two tabs. The data-cy-notes-share-sidebar hook is deliberately unchanged, since playwright/e2e/basic.spec.ts asserts on it.

Tests

New playwright/e2e/note-sidebar.spec.ts:

• opens the versions tab from the actions menu
• refreshes the versions list once a version is restored
• keeps the editor behind a spinner while a restored version loads
• shows the size, the modification date and the owner of the note
• renders the allow-listed tabs only
• switches between the sharing and versions tabs
• fills the sharing icon only while its tab is active
• lines the tab icons up with each other
• falls back to the first tab when the requested one is unavailable
• markdown editor › opens the sidebar from the editor actions menu

openNoteActions() moved from note-actions.spec.ts into support/note.ts so both specs share it. Two helpers were added there as well: setNoteMode() for the markdown-editor case, and createNoteRevisions(), which creates a note and then rewrites it over WebDAV — going around the app on purpose, as writing through it would retitle and thereby rename the note. Both take Playwright's isolated request fixture rather than page.request, whose basic auth would replace the session cookie the browser is logged in with.

src/tests/sidebarTabs.spec.js covers selectNoteSidebarTabs() without a server or a browser: the allow-list, the ordering including a missing order, that a tab is kept while the node it would judge is still loading, that the predicate is asked with the node once there is one, that a predicate throwing drops only that tab, and that the registry it is handed is not reordered in place. It needs the vitest setup from #1989, which should merge first.

🖼️ Screenshots

🏚️ Before	🏡 After

🤖 AI (if applicable)

• The content of this PR was partly or fully generated using AI

[enjeck]

Pls add screenshots showing what the UI looks like. Maybe significant enough tp require designer input

[Copilot]

Pull request overview

Copilot reviewed 10 out of 10 changed files in this pull request and generated 3 comments.

Suppressed comments (6)

src/components/NotePlain.vue:1

• refreshNote() now awaits and can throw; if it rejects, startRefreshTimer() won’t run and (more importantly) onFileRestored() won’t reach this.loading = false, potentially leaving the editor stuck behind the spinner. Wrap the awaited call(s) in try { ... } finally { ... } so the refresh timer is always restarted and loading is always cleared after restore attempts.

<!--

src/components/NoteSidebarSubname.vue:22

• When node.owner is present but owner-display-name is missing, NcUserBubble will receive an undefined displayName, which can render as an empty/odd label. Consider falling back to a sensible default (e.g., node.owner) when owner-display-name is not available.

		<template v-if="node.owner">
			<span class="note-sidebar-subname__separator">•</span>
			<NcUserBubble class="note-sidebar-subname__owner"
				:displayName="ownerDisplayName"
				:title="t('notes', 'Owner')"
				:user="node.owner"
			/>
		</template>

src/components/NoteSidebarSubname.vue:52

• When node.owner is present but owner-display-name is missing, NcUserBubble will receive an undefined displayName, which can render as an empty/odd label. Consider falling back to a sensible default (e.g., node.owner) when owner-display-name is not available.

		ownerDisplayName() {
			return this.node.attributes?.['owner-display-name']
		},

playwright/support/note.ts:53

• The fixed 3.5s sleep per revision can significantly slow down e2e runs and may still be flaky if server-side thinning behavior changes. Prefer a more deterministic wait (e.g., poll until versions endpoint shows the expected count / mtime change) or centralize the delay as a named constant with a brief rationale and a single place to tune it.

	for (const content of revisions.slice(1)) {
		// recent versions are thinned out to one per two seconds
		await new Promise((resolve) => setTimeout(resolve, 3500))
		const written = await request.put(`/remote.php/dav/files/${apiUser()}${path}`, {
			headers: apiHeaders(),
			data: content,
		})
		expect(written.ok(), 'writing a revision').toBeTruthy()
	}

src/components/NoteItem.vue:50

• hasVersionsTab() is called during render and queries getSidebarTabs() each time. If the registry lookup is non-trivial, this can add avoidable overhead in list rendering; also, if sidebar tabs are registered asynchronously, this approach may not update without another reactive trigger. Consider caching this as a computed value (optionally refreshed when the sidebar registry changes) rather than recalculating on every render.

			<NcActionButton v-if="hasVersionsTab()" @click="onShowVersions">
				<template #icon>
					<BackupRestoreIcon :size="20" />
				</template>
				{{ t('notes', 'Versions') }}
			</NcActionButton>

src/components/NoteItem.vue:352

• hasVersionsTab() is called during render and queries getSidebarTabs() each time. If the registry lookup is non-trivial, this can add avoidable overhead in list rendering; also, if sidebar tabs are registered asynchronously, this approach may not update without another reactive trigger. Consider caching this as a computed value (optionally refreshed when the sidebar registry changes) rather than recalculating on every render.

		hasVersionsTab() {
			return getSidebarTabs().some((tab) => tab?.id === 'files_versions')
		},

[AndyScherzinger]

restoring versions while using Nextcloud Text leads to unexpected version creations, still investigating, so putting it back to draft state until resolved. Sorry for the GH notification noise.

[AndyScherzinger]

Update: versioning works well, but the above is an issue in Text, now reported at nextcloud/text#9077