@conduction/nextcloud-vue 2.96.0 → 2.98.0

package/src/components/CnChecklistRunWidget/index.js

@@ -0,0 +1,27 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * CnChecklistRunWidget — self-registers the `checklist-run` widget type (a
+ * checklist answered a page of questions at a time, with a note and photos)
+ * into the shared dashboardWidgetRegistry at module load. Renderer only: the
+ * questions and where the answers go are declared in the manifest.
+ */
+
+import CnChecklistRunWidget from './CnChecklistRunWidget.vue'
+import { registerDashboardWidget } from '../CnWidgetGrid/dashboardWidgetRegistry.js'
+
+registerDashboardWidget('checklist-run', {
+	renderer: CnChecklistRunWidget,
+	form: null,
+	defaultContent: {
+		questions: { register: '', schema: '', filter: {} },
+		pageSize: 1,
+	},
+	displayName: 'Checklist run',
+	icon: 'ClipboardCheckOutline',
+	surfaces: ['detail-page', 'app-dashboard'],
+})
+
+export { CnChecklistRunWidget }
+export default CnChecklistRunWidget

package/src/components/CnConversationThread/CnConversationThread.md

@@ -49,3 +49,15 @@ Posting to an endpoint. The reply goes out as `{ message, ...payload }`. `title-
   </template>
 </CnConversationThread>
 ```
+
+While the messages load, `loading` makes the thread say so (in a status region) instead of showing the empty text. A
+message's `channel` is shown after its time:
+
+```vue
+<CnConversationThread
+  title="Contact"
+  :loading="false"
+  :messages="[
+    { id: 1, author: 'Sanne de Vries', time: '2026-10-04T10:52:00', side: 'them', channel: 'Message box', text: 'Thank you.' },
+  ]" />
+```

package/src/components/CnConversationThread/CnConversationThread.vue

@@ -17,7 +17,13 @@
 			{{ title }}
 		</component>
 
-		<p v-if="rows.length === 0" class="cn-conversation-thread__empty" data-testid="cn-conversation-empty">
+		<p v-if="loading && rows.length === 0"
+			class="cn-conversation-thread__empty"
+			role="status"
+			data-testid="cn-conversation-loading">
+			{{ loadingText }}
+		</p>
+		<p v-else-if="rows.length === 0" class="cn-conversation-thread__empty" data-testid="cn-conversation-empty">
 			{{ emptyText }}
 		</p>
 
@@ -32,8 +38,10 @@
 				<span class="cn-conversation-thread__avatar" aria-hidden="true">{{ row.initials }}</span>
 				<div class="cn-conversation-thread__bubble">
 					<span class="cn-conversation-thread__meta">
+						<span class="hidden-visually">{{ row.directionLabel }}</span>
 						<span class="cn-conversation-thread__author">{{ row.author }}</span>
 						<time v-if="row.timeLabel" :datetime="row.datetime || null">{{ row.timeLabel }}</time>
+						<span v-if="row.channel" class="cn-conversation-thread__channel" data-testid="cn-conversation-channel">{{ row.channel }}</span>
 					</span>
 					<span class="cn-conversation-thread__text">{{ row.text }}</span>
 				</div>
@@ -123,9 +131,10 @@ export default {
 
 	props: {
 		/**
-		 * The messages, oldest first: `{ id?, author?, time?, text, side? }`.
+		 * The messages, oldest first: `{ id?, author?, time?, text, side?, channel? }`.
 		 * `side` is `us` or `them` (default `them`). `time` is an ISO
-		 * date, or any text to show as is.
+		 * date, or any text to show as is. `channel` is shown after the time
+		 * ("E-mail", "Phone note").
 		 */
 		messages: {
 			type: Array,
@@ -189,6 +198,12 @@ export default {
 			default: () => ({}),
 		},
 
+		/** Whether the messages are still loading; with none yet the thread says so. */
+		loading: {
+			type: Boolean,
+			default: false,
+		},
+
 		/** Shown when there are no messages yet. */
 		emptyText: {
 			type: String,
@@ -221,7 +236,7 @@ export default {
 		/**
 		 * The messages, with author, side, time and initials resolved.
 		 *
-		 * @return {Array<{key: string, author: string, initials: string, side: string, text: string, timeLabel: string, datetime: string}>} The rows.
+		 * @return {Array<{key: string, author: string, initials: string, side: string, text: string, timeLabel: string, datetime: string, channel: string, directionLabel: string}>} The rows.
 		 * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-conversation-thread
 		 */
 		rows() {
@@ -241,6 +256,8 @@ export default {
 						text: message.text === undefined || message.text === null ? '' : String(message.text),
 						timeLabel: time.label,
 						datetime: time.datetime,
+						channel: typeof message.channel === 'string' ? message.channel : '',
+						directionLabel: side === 'us' ? t('nextcloud-vue', 'Sent message') : t('nextcloud-vue', 'Received message'),
 					}
 				})
 		},
@@ -264,6 +281,11 @@ export default {
 		fallbackLabel() {
 			return t('nextcloud-vue', 'Conversation')
 		},
+
+		/** @return {string} What the thread says while its messages load. */
+		loadingText() {
+			return t('nextcloud-vue', 'Loading messages…')
+		},
 	},
 
 	methods: {
@@ -455,4 +477,8 @@ export default {
 	gap: calc(2.5 * var(--default-grid-baseline));
 	justify-content: flex-end;
 }
+
+.cn-conversation-thread__channel {
+	color: var(--color-text-maxcontrast);
+}
 </style>

package/src/components/CnConversationThread/CnConversationWidget.vue

@@ -7,29 +7,44 @@
 	<div class="cn-case-widget-card">
 		<CnConversationThread
 			:messages="messages"
-			:title="content.title || ''"
+			:title="tr(content.title || '')"
 			:allowReply="content.allowReply !== false"
-			:replyLabel="content.replyLabel || undefined"
-			:placeholder="content.placeholder || ''"
-			:sendLabel="content.sendLabel || undefined"
-			:endpoint="endpoint"
-			:emptyText="content.emptyText || undefined"
+			:replyLabel="content.replyLabel ? tr(content.replyLabel) : undefined"
+			:placeholder="tr(content.placeholder || '')"
+			:sendLabel="content.sendLabel ? tr(content.sendLabel) : undefined"
+			:endpoint="replyAction ? '' : endpoint"
+			:loading="loading"
+			:emptyText="content.emptyText ? tr(content.emptyText) : undefined"
+			@send="onSend"
 			@sent="onSent" />
 	</div>
 </template>
 
 <script>
 import CnConversationThread from './CnConversationThread.vue'
+import { dispatchAction } from '../../utils/actionsDispatcher.js'
+import { fetchReferenceObjects } from '../../utils/boardReferenceColumns.js'
 import { readPath } from '../../utils/readPath.js'
+import { hasUnresolvedDeepTokens, resolveDeepTokens } from '../../utils/resolveFilterTokens.js'
 
 /**
  * CnConversationWidget: the `conversation` detail widget type.
  *
- * Renders CnConversationThread from a list on the bound record:
- * `content: { field, endpoint?, authorField?, timeField?, textField?, sideField?, usValue? }`.
- * `@objectId` in `endpoint` is replaced by the record's id. A reply the
- * endpoint accepts is shown at once, until the record is read again.
- * Resolved by its registry key, and exported for an app that renders it itself.
+ * Renders CnConversationThread from the messages of a record, oldest first.
+ * The messages are a list on the bound record (`field`), or the objects of a
+ * register list (`source: { register, schema, filter?, limit? }`, the filter
+ * token-resolved like a record-list's: `{ "case": "@objectId" }`).
+ *
+ * Mapping keys name where each message keeps its parts: `textField` (alias
+ * `bodyField`), `timeField` (alias `timestampField`), `authorField` (alias
+ * `senderField`), `sideField` (alias `directionField`) with `usValue` (alias
+ * `outValue`) for the messages the organisation sent, and `channelField` with
+ * an optional `channelMap` from stored value to label ("email" to "E-mail").
+ *
+ * The reply box posts to `endpoint` (`@objectId` filled in), or runs
+ * `replyAction`, an action descriptor the app decides the meaning of: it is
+ * dispatched with `args: [{ text, objectId }]` and `props.text`. After a send
+ * the source is read again.
  */
 export default {
 	name: 'CnConversationWidget',
@@ -38,8 +53,19 @@ export default {
 		CnConversationThread,
 	},
 
+	inject: {
+		cnTranslate: { default: () => (key) => key },
+		/** Pre-bound action dispatcher of the page, for `replyAction`. */
+		cnDispatchAction: { default: null },
+	},
+
 	props: {
-		/** The widget's content. `field` is the dot-path to the messages on the record. */
+		/**
+		 * The widget's content: `field` (the dot-path to the messages on the
+		 * record) or `source`, the mapping keys, `endpoint` or `replyAction`,
+		 * and the texts (`title`, `replyLabel`, `placeholder`, `sendLabel`,
+		 * `emptyText`, translated).
+		 */
 		content: {
 			type: Object,
 			default: () => ({}),
@@ -62,29 +88,63 @@ export default {
 		return {
 			/** Replies sent from this widget that the record does not hold yet. */
 			sentHere: [],
+			/** The messages read from `source`. */
+			listed: [],
+			/** Whether `source` is being read. */
+			loading: false,
 		}
 	},
 
 	computed: {
+		/** @return {object|null} The register list the messages come from, or null. */
+		source() {
+			const source = this.content?.source
+			return source && typeof source === 'object' && source.register && source.schema ? source : null
+		},
+
+		/** @return {object|null} The reply action, or null. */
+		replyAction() {
+			const action = this.content?.replyAction
+			return action && typeof action === 'object' ? action : null
+		},
+
 		/**
-		 * The record's messages in the thread's shape, plus the replies sent here.
+		 * The messages in the thread's shape, oldest first, plus the replies
+		 * sent here.
 		 *
 		 * @return {Array<object>} The messages.
 		 * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-conversation-thread
+		 * @spec openspec/changes/conversation-source/specs/conversation-source/spec.md#requirement-a-conversation-reads-its-messages-from-a-list-and-maps-their-parts
 		 */
 		messages() {
-			const c = this.content
-			const value = readPath(this.objectData || {}, c.field || 'messages')
-			const usValue = String(c.usValue === undefined ? 'us' : c.usValue)
-			const stored = (Array.isArray(value) ? value : [])
+			const c = this.content || {}
+			const raw = this.source ? this.listed : readPath(this.objectData || {}, c.field || 'messages')
+			const usValue = String(c.outValue ?? c.usValue ?? 'us')
+			const channelMap = c.channelMap && typeof c.channelMap === 'object' ? c.channelMap : {}
+			const stored = (Array.isArray(raw) ? raw : [])
 				.filter((message) => message && typeof message === 'object')
-				.map((message) => ({
-					id: message.id,
-					author: readPath(message, c.authorField || 'author'),
-					time: readPath(message, c.timeField || 'time'),
-					text: readPath(message, c.textField || 'text'),
-					side: String(readPath(message, c.sideField || 'side')) === usValue ? 'us' : 'them',
-				}))
+				.map((message, index) => {
+					const channel = c.channelField ? readPath(message, c.channelField) : undefined
+					const channelKey = channel === undefined || channel === null ? '' : String(channel)
+					return {
+						id: message.id ?? `message-${index}`,
+						author: readPath(message, c.senderField || c.authorField || 'author'),
+						time: readPath(message, c.timestampField || c.timeField || 'time'),
+						text: readPath(message, c.bodyField || c.textField || 'text'),
+						side: String(readPath(message, c.directionField || c.sideField || 'side')) === usValue ? 'us' : 'them',
+						channel: channelKey === '' ? '' : this.tr(Object.hasOwn(channelMap, channelKey) ? channelMap[channelKey] : channelKey),
+						order: index,
+					}
+				})
+			const at = (message) => {
+				const ms = Date.parse(message.time)
+				return Number.isNaN(ms) ? null : ms
+			}
+			stored.sort((a, b) => {
+				const ta = at(a)
+				const tb = at(b)
+				return (ta === null || tb === null || ta === tb) ? a.order - b.order : ta - tb
+			})
 			return [...stored, ...this.sentHere]
 		},
 
@@ -101,6 +161,11 @@ export default {
 			}
 			return url.replace(/@objectId/g, encodeURIComponent(String(this.objectId ?? '')))
 		},
+
+		/** @return {object} The token context for `source.filter` and `replyAction`. */
+		tokenCtx() {
+			return { objectId: this.objectId, object: this.objectData || {} }
+		},
 	},
 
 	watch: {
@@ -108,9 +173,87 @@ export default {
 		objectData() {
 			this.sentHere = []
 		},
+
+		objectId: {
+			immediate: true,
+			handler() {
+				this.loadSource()
+			},
+		},
 	},
 
 	methods: {
+		/**
+		 * Translate through the app's translate.
+		 *
+		 * @param {string} key The source string.
+		 * @return {string}
+		 */
+		tr(key) {
+			return key && typeof this.cnTranslate === 'function' ? this.cnTranslate(key) : (key || '')
+		},
+
+		/**
+		 * Read the messages from `source`. A filter whose token does not
+		 * resolve sends no request; a failed read leaves the thread empty.
+		 *
+		 * @return {Promise<void>}
+		 * @spec openspec/changes/conversation-source/specs/conversation-source/spec.md#requirement-a-conversation-reads-its-messages-from-a-list-and-maps-their-parts
+		 */
+		async loadSource() {
+			if (!this.source) {
+				return
+			}
+			const raw = this.source.filter || {}
+			const filter = resolveDeepTokens(raw, this.tokenCtx)
+			const emptied = Object.keys(raw).some((key) => typeof raw[key] === 'string' && raw[key].startsWith('@') && (filter[key] === '' || filter[key] === null || filter[key] === undefined))
+			if (emptied || hasUnresolvedDeepTokens(filter)) {
+				this.listed = []
+				return
+			}
+			this.loading = true
+			try {
+				this.listed = await fetchReferenceObjects({ register: this.source.register, schema: this.source.schema, filter, limit: this.source.limit || 200 })
+				this.sentHere = []
+			} catch {
+				this.listed = []
+			} finally {
+				this.loading = false
+			}
+		},
+
+		/**
+		 * Run `replyAction` with the reply, when there is one; the endpoint
+		 * path is the thread's own.
+		 *
+		 * @param {string} text The reply.
+		 * @return {Promise<void>}
+		 * @spec openspec/changes/conversation-source/specs/conversation-source/spec.md#requirement-a-reply-can-run-an-app-action
+		 */
+		async onSend(text) {
+			if (!this.replyAction) {
+				return
+			}
+			const resolved = resolveDeepTokens(this.replyAction, this.tokenCtx)
+			const action = { ...resolved, args: [{ text, objectId: this.objectId }], props: { ...(resolved.props || {}), text } }
+			const result = typeof this.cnDispatchAction === 'function'
+				? this.cnDispatchAction(action)
+				: dispatchAction(action, { router: this.$router || null })
+			try {
+				const outcome = await result
+				if (outcome === false) {
+					return
+				}
+			} catch {
+				return
+			}
+			if (this.source) {
+				await this.loadSource()
+				return
+			}
+			this.onSent({ text })
+		},
+
 		/**
 		 * Show an accepted reply at once, without waiting for the record.
 		 *

package/src/components/CnDashboardPage/CnDashboardPage.vue

@@ -1079,6 +1079,7 @@ const CHART_PROP_KEYS = [
 	'barMax',
 	'footnote',
 	'highlight',
+	'cellSource',
 ]
 
 /**

package/src/components/CnDataTable/CnDataTable.vue

@@ -408,6 +408,7 @@ import { fillTemplate, joinTemplateParts } from '../../utils/fillTemplate.js'
 import { lensUnavailableText, readLensReports } from '../../utils/lensAvailability.js'
 import { followLinkClick, openRowTarget, resolveHref } from '../../utils/linkNavigation.js'
 import { nextSortState } from '../../utils/multiColumnSort.js'
+import { readPath } from '../../utils/readPath.js'
 import { isNewTabClick, isNewTabHandled, isRowMiddleClick, markNewTabHandled, preventMiddleClickAutoscroll } from '../../utils/rowAuxClick.js'
 import { DEFAULT_ROW_INDICATOR_CAP, resolveRowIndicators } from '../../utils/rowIndicators.js'
 import { columnsFromSchema } from '../../utils/schema.js'
@@ -1841,8 +1842,11 @@ export default {
 				if (v === undefined) {
 					return this.aggregateLoading ? '…' : '—'
 				}
+				if (v === null && !(typeof col.aggregate.zeroLabel === 'string' && col.aggregate.zeroLabel !== '')) {
+					return '—'
+				}
 				const zeroLabel = col.aggregate.zeroLabel
-				if ((v === 0 || v === '0') && typeof zeroLabel === 'string' && zeroLabel !== '') {
+				if ((v === 0 || v === '0' || v === null) && typeof zeroLabel === 'string' && zeroLabel !== '') {
 					return typeof this.cnTranslate === 'function' ? this.cnTranslate(zeroLabel) : zeroLabel
 				}
 				return v
@@ -1872,17 +1876,21 @@ export default {
 		},
 
 		/**
-		 * For every column that declares `aggregate` (currently `op: "count"`),
-		 * issue one `_limit=0` count request per visible row against the related
-		 * OpenRegister collection and cache the totals in `aggregateValues`.
+		 * For every column that declares `aggregate`, issue one request per
+		 * visible row against the related OpenRegister collection and cache the
+		 * answer in `aggregateValues`: `op: "count"` asks `_limit=0` for the
+		 * total, `op: "max"` asks for the one object with the highest `field`
+		 * (`_limit=1`, sorted descending) and keeps that value, null when there
+		 * is none (shown as `zeroLabel`, else a dash).
 		 * Batched with `Promise.all`; a per-request failure degrades that one
 		 * cell to `'—'` (logged), never the page. A monotonic request id
 		 * discards a stale batch when `rows` / columns change mid-flight.
 		 *
 		 * @return {Promise<void>}
+		 * @spec openspec/changes/masked-formatter-max-aggregate/specs/index-page/spec.md#requirement-a-column-aggregate-can-take-the-highest-value
 		 */
 		async loadAggregates() {
-			const aggCols = this.effectiveColumns.filter((c) => c && c.aggregate && c.aggregate.op === 'count')
+			const aggCols = this.effectiveColumns.filter((c) => c && c.aggregate && (c.aggregate.op === 'count' || (c.aggregate.op === 'max' && c.aggregate.field)))
 			if (aggCols.length === 0) {
 				if (Object.keys(this.aggregateValues).length > 0) {
 					this.aggregateValues = {}
@@ -1903,11 +1911,21 @@ export default {
 						continue
 					}
 					const where = this.resolveAggregateWhere(agg.where, row)
-					jobs.push(axios.get(generateUrl(`/apps/openregister/api/objects/${agg.register}/${agg.schema}`), {
-						params: { ...where, _limit: 0 },
-					})
+					// `max`: the highest `field` among the related objects, as the
+					// first of them sorted on it descending ("Laatste contact").
+					const isMax = agg.op === 'max'
+					const params = isMax
+						? { ...where, _limit: 1, [`_order[${agg.field}]`]: 'desc' }
+						: { ...where, _limit: 0 }
+					jobs.push(axios.get(generateUrl(`/apps/openregister/api/objects/${agg.register}/${agg.schema}`), { params })
 						.then((res) => {
 							const d = res && res.data
+							if (isMax) {
+								const first = d && Array.isArray(d.results) ? d.results[0] : undefined
+								const top = first === undefined ? undefined : readPath(first, agg.field)
+								next[rowKey][col.key] = top === undefined || top === '' ? null : top
+								return
+							}
 							next[rowKey][col.key] = (d && (d.total ?? (Array.isArray(d.results) ? d.results.length : undefined))) ?? 0
 						})
 						.catch((e) => {

package/src/components/CnDetailPage/CnDetailPage.md

@@ -434,6 +434,54 @@ Four levels of action and the case surfaces around them. All opt in. See [the re
 
 `previousTo` and `nextTo` (default `null`) take `useListNavigation`'s `previousRoute` / `nextRoute` and turn the previous and next controls into real links, so they can be opened in a new tab. The link navigates by itself; `previous-record` / `next-record` are still emitted, with `{ event, to }`, and `goPrevious` / `goNext` do not push again when they receive that payload.
 
+## Records that are not objects (`config.entitySource`)
+
+A detail page reads its record from the object store through `register` +
+`schema`. A record that is not a register/schema object names a registered
+entity source instead, the same registry and the same name `CnIndexPage`
+lists it with. `organisations` reads the OpenRegister organisation whose uuid
+is the route's id (`GET /apps/openregister/api/organisations/{uuid}`):
+
+```json
+{
+  "id": "organisation-detail",
+  "route": "/organisations/:id",
+  "type": "detail",
+  "config": {
+    "entitySource": "organisations",
+    "statusPill": { "field": "status" },
+    "typePill": { "field": "type" },
+    "headerFields": [{ "key": "slug" }],
+    "layout": [{ "id": "1", "widgetId": "facts", "gridX": 0, "gridY": 0, "gridWidth": 6 }],
+    "widgets": [{
+      "id": "facts",
+      "type": "facts",
+      "title": "Details",
+      "content": { "fields": [
+        { "path": "slug", "label": "Slug" },
+        { "path": "created", "label": "Created", "format": "date" },
+        { "path": "contactEmail", "label": "Contact", "format": "email" },
+        { "path": "kvk", "label": "KvK" }
+      ] }
+    }]
+  }
+}
+```
+
+The record feeds everything a fetched object feeds: the title, the pills, the
+header fields, the widgets, and the `@objectId` / `@object.*` tokens. A tab
+that lists register objects belonging to the organisation filters on
+`@objectId`, e.g. `{ "type": "object-list", "content": { "register": "...",
+"schema": "...", "filter": { "tenantRef": "@objectId" } } }`. The record's
+`id` is its uuid, as an object's is.
+
+`entitySource` wins over `register` + `schema`. A name that is unknown, or a
+source that cannot read one record, shows no record and warns in the console.
+A refusal (403) or a missing record (404) shows the not-found state; which
+records the viewer may read is OpenRegister's decision. Refresh and
+`cn:page:refresh` re-read the record. There is no Edit: a record source has
+no schema form.
+
 ## Not found
 
 When the schema-driven fetch answers 404 the page shows a not-found state whose back button is a router link to `notFoundRoute` (default `null`, which means the app root `/`). `notFoundRouteLabel` names that page in the button's "Back to …" label.