@conduction/nextcloud-vue 2.132.0 → 2.133.0

package/src/store/useObjectStore.js

@@ -714,10 +714,20 @@ const baseActions = {
 	 * @param {{error?: object|null}} [options.outcome] Opt-in sink for THIS call's own result: `error` is set to the error it records on `errors[type]`, or `null` on success. Unlike `errors[type]`, which every call for the type shares, a later call cannot overwrite it.
 	 * @param {boolean} [options.append] Add the fetched page after the rows already stored instead of replacing them. Dropped when the stored rows are no longer the page before it, or when `options.isCurrent()` returns false (the query changed meanwhile).
 	 * @param {() => boolean} [options.isCurrent] With `append`: asked once the page arrives; false drops it.
-	 * @return {Promise<Array>} The fetched collection (also stored in state)
+	 * @return {Promise<Array>} The fetched collection (also stored in state, unless a newer non-append fetch for the type started meanwhile)
+	 * @spec openspec/changes/list-keeps-its-newest-query/specs/list-keeps-its-newest-query/spec.md#requirement-the-newest-list-query-decides-what-the-list-shows
 	 */
 	async fetchCollection(type, params = {}, options = {}) {
 		const outcome = (options && typeof options.outcome === 'object' && options.outcome) || null
+		const append = options?.append === true
+		// Responses can arrive out of order; only the newest query for the
+		// type may write the list. An append page belongs to the query before it.
+		const currentQuery = this.__currentCollectionQuery || (this.__currentCollectionQuery = {})
+		if (!append) {
+			currentQuery[type] = JSON.stringify(params)
+		}
+		const query = currentQuery[type]
+		const superseded = () => currentQuery[type] !== query
 		this.loading = { ...this.loading, [type]: true }
 		this.errors = { ...this.errors, [type]: null }
 
@@ -746,10 +756,13 @@ const baseActions = {
 
 			if (!response.ok) {
 				const failure = await parseResponseError(response, type)
-				this.errors = { ...this.errors, [type]: failure }
 				if (outcome) {
 					outcome.error = failure
 				}
+				if (superseded()) {
+					return []
+				}
+				this.errors = { ...this.errors, [type]: failure }
 				// eslint-disable-next-line no-console -- diagnostic for a failure this code already degrades from
 				console.error(`Error fetching ${type} collection:`, failure)
 				return []
@@ -757,8 +770,13 @@ const baseActions = {
 
 			const data = await response.json()
 			const results = data.results || data
-			const append = options?.append === true
 
+			if (superseded()) {
+				if (outcome) {
+					outcome.error = null
+				}
+				return append ? [] : results
+			}
 			const stale = append && (
 				Number(this.pagination[type]?.page || 1) !== Number(params._page || 1) - 1
 				|| (typeof options.isCurrent === 'function' && !options.isCurrent())
@@ -797,15 +815,20 @@ const baseActions = {
 			const failure = error.name === 'TypeError'
 				? networkError(error)
 				: genericError(error)
-			this.errors = { ...this.errors, [type]: failure }
 			if (outcome) {
 				outcome.error = failure
 			}
+			if (superseded()) {
+				return []
+			}
+			this.errors = { ...this.errors, [type]: failure }
 			// eslint-disable-next-line no-console -- diagnostic for a failure this code already degrades from
 			console.error(`Error fetching ${type} collection:`, error)
 			return []
 		} finally {
-			this.loading = { ...this.loading, [type]: false }
+			if (!superseded()) {
+				this.loading = { ...this.loading, [type]: false }
+			}
 		}
 	},
 

package/src/utils/detailActionModel.js

@@ -17,6 +17,7 @@
  */
 
 import { variantForColor } from './headerFieldChips.js'
+import { isObjectRowsSpec, objectRowsOf } from './objectRows.js'
 import { readPath } from './readPath.js'
 import { evaluateVisibleWhenLocal } from './visibleWhen.js'
 
@@ -335,6 +336,7 @@ export function pillLook(look) {
  * @param {object|null} object The record.
  * @return {number|null} The count, or null when the tab declares none.
  * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-tab-counts-and-overflow
+ * @spec openspec/changes/record-list-object-rows/specs/record-list/spec.md#requirement-a-tab-can-count-the-rows-its-record-holds
  */
 export function resolveTabCount(tab, object) {
 	if (!tab || typeof tab !== 'object') {
@@ -343,6 +345,10 @@ export function resolveTabCount(tab, object) {
 	if (typeof tab.count === 'number' && Number.isFinite(tab.count)) {
 		return tab.count
 	}
+	// `countObjectRows`: the rows the record holds where it points, as a record list's `objectRows`.
+	if (isObjectRowsSpec(tab.countObjectRows)) {
+		return objectRowsOf(object, tab.countObjectRows).length
+	}
 	if (typeof tab.countField !== 'string' || tab.countField === '') {
 		const counts = object && typeof object === 'object' && object['@self'] && object['@self'].unreadCounts
 		const key = tab.unreadKey || tab.id || tab.widgetId

package/src/utils/listLenses.js

@@ -74,6 +74,12 @@ export function splitViewsIntoTabs(views, tabIds) {
  * One saved view as a tab for CnQuickFilterBar, so a lens renders through the
  * tab strip the page already has rather than a second one beside it.
  *
+ * Its filter is the view's own `filters`/`filter`, else what an OpenRegister
+ * view (and a default view) keeps in its query: `query.filters` with the
+ * locked conditions of `query.overrides.lockedFilters` under them. Reading
+ * only the first left a stored view with no filter, so every view in the
+ * side panel counted the whole list.
+ *
  * @param {object} view A saved view.
  * @return {{id: string, label: string, filter: object}}
  */
@@ -81,10 +87,23 @@ export function viewAsTab(view) {
 	return {
 		id: viewIdOf(view),
 		label: (view && (view.title || view.name)) || viewIdOf(view),
-		filter: (view && (view.filters || view.filter)) || {},
+		filter: (view && (view.filters || view.filter)) || queryFilterOf(view),
 	}
 }
 
+/**
+ * The conditions a stored view's query applies: its locked filters, then its filters.
+ *
+ * @param {object} view A saved view.
+ * @return {object}
+ */
+function queryFilterOf(view) {
+	const query = view && view.query && typeof view.query === 'object' ? view.query : {}
+	const plain = (value) => (value && typeof value === 'object' && !Array.isArray(value) ? value : {})
+	const locked = plain(query.overrides && query.overrides.lockedFilters)
+	return { ...locked, ...plain(query.filters) }
+}
+
 /**
  * The teams this person is treated as having claimed.
  *

package/src/utils/objectRows.js

@@ -0,0 +1,55 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * The rows a record holds in one of its fields, as `objectRows` names them:
+ * `{ path, where?, valuePath? }`. The list at `path`, narrowed to the entry
+ * matching `where` when set (`{ name: "onderzoeksstappen" }` in a case's
+ * answers), its `valuePath` taken; a JSON string is decoded. Anything that is
+ * not a list of objects is no rows. The record is read as the page read it, so
+ * its own read rules already decided what is in it.
+ *
+ * @spec openspec/changes/record-list-object-rows/specs/record-list/spec.md#requirement-a-record-list-can-list-rows-the-page-record-holds
+ */
+import { readPath } from './readPath.js'
+
+/**
+ * Whether a declaration names rows on a record.
+ *
+ * @param {unknown} spec The declaration.
+ * @return {boolean}
+ */
+export function isObjectRowsSpec(spec) {
+	return Boolean(spec && typeof spec === 'object' && typeof spec.path === 'string' && spec.path !== '')
+}
+
+/**
+ * The rows a record holds where `spec` points.
+ *
+ * @param {object|null} object The record.
+ * @param {{path: string, where?: object, valuePath?: string}} spec The declaration.
+ * @return {Array<object>} The rows.
+ */
+export function objectRowsOf(object, spec) {
+	if (!object || typeof object !== 'object' || !isObjectRowsSpec(spec)) {
+		return []
+	}
+	const valuePath = typeof spec.valuePath === 'string' && spec.valuePath !== '' ? spec.valuePath : ''
+	let value = readPath(object, spec.path)
+	if (spec.where && typeof spec.where === 'object') {
+		const entries = Array.isArray(value) ? value : []
+		const match = entries.find((entry) => entry && typeof entry === 'object'
+			&& Object.entries(spec.where).every(([key, wanted]) => entry[key] === wanted))
+		value = match && valuePath ? readPath(match, valuePath) : match
+	} else if (valuePath) {
+		value = readPath(value, valuePath)
+	}
+	if (typeof value === 'string') {
+		try {
+			value = JSON.parse(value)
+		} catch {
+			value = undefined
+		}
+	}
+	return Array.isArray(value) ? value.filter((row) => row && typeof row === 'object' && !Array.isArray(row)) : []
+}