@conduction/nextcloud-vue 2.97.0 → 2.99.0

package/src/utils/builtInFormatters.js

@@ -417,6 +417,38 @@ export function formatConnectionSettingsLabel(value) {
 		: ''
 }
 
+/**
+ * Show a value with all but its last characters replaced by `*`, as the facts
+ * widget's `masked` format does: an IBAN or a BSN reads `*****4567`.
+ *
+ * DISPLAY ONLY, NOT ACCESS CONTROL. The full value is still in the row the
+ * page received; a reader with the browser's developer tools can read it.
+ * A value the reader must not have belongs hidden in OpenRegister (property
+ * authorization), not masked here.
+ *
+ * The column's `formatterOptions.visible` sets how many characters stay
+ * (default 4); at most five `*` are drawn, so the length does not leak.
+ * Null-safe: `''` for null or empty.
+ *
+ * @param {unknown} value The value.
+ * @param {object} [_row] The full row (unused).
+ * @param {object} [_property] The schema property (unused).
+ * @param {{visible?: number}} [options] The column's `formatterOptions`.
+ * @return {string} The masked value.
+ * @spec openspec/changes/masked-formatter-max-aggregate/specs/index-page/spec.md#requirement-a-column-can-mask-its-value-for-display
+ */
+export function formatMasked(value, _row, _property, options) {
+	if (value === null || value === undefined || value === '') {
+		return ''
+	}
+	const text = String(value)
+	const visible = Number.isInteger(options && options.visible) && options.visible >= 0 ? options.visible : 4
+	if (text.length <= visible) {
+		return text
+	}
+	return '*'.repeat(Math.min(text.length - visible, 5)) + (visible > 0 ? text.slice(-visible) : '')
+}
+
 /**
  * Built-in formatter registry merged under any consumer-registered
  * `formatters` in `CnAppRoot`'s `cnFormatters` provide.
@@ -433,4 +465,5 @@ export const BUILT_IN_FORMATTERS = {
 	count: formatCount,
 	connectionStatus: formatConnectionStatus,
 	connectionSettingsLabel: formatConnectionSettingsLabel,
+	masked: formatMasked,
 }

package/src/utils/libraryWidgetKeys.js

@@ -93,6 +93,7 @@ export const DASHBOARD_CATALOG_WIDGET_KEYS = Object.freeze([
 	'banner',
 	'calendar',
 	'chart',
+	'checklist-run',
 	'chips-field',
 	'choice-picker',
 	'container',
@@ -151,6 +152,7 @@ export const DASHBOARD_CATALOG_WIDGET_KEYS = Object.freeze([
 	'toggle-table',
 	'video',
 	'week-strip',
+	'working-calendar',
 	'workspace-filter',
 ])
 

package/src/utils/matrixCells.js

@@ -0,0 +1,154 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * matrixCells: lay out records that each hold one matrix cell as the rows and
+ * columns a `matrix` chart draws.
+ *
+ * A matrix kept as data is often stored one record per cell: the row it sits
+ * in, the column, and the value. This turns such a list into one series per
+ * row with a value per column, in a stable order, so the chart reads the same
+ * matrix the app computes with instead of a copy written into a manifest.
+ *
+ * @module utils/matrixCells
+ * @spec openspec/changes/matrix-cell-records/specs/matrix-cell-records/spec.md#requirement-a-matrix-can-read-its-cells-from-records
+ */
+
+import { readPath } from './readPath.js'
+
+/**
+ * A stored key as text, or null when there is none.
+ *
+ * @param {unknown} value The stored value.
+ * @return {string|null} The key.
+ */
+function keyOf(value) {
+	if (value === null || value === undefined || value === '' || typeof value === 'object') {
+		return null
+	}
+	return String(value)
+}
+
+/**
+ * The keys in the order they are drawn: the listed order first, then keys
+ * with an order value (lowest first), then the rest in natural order.
+ *
+ * @param {Map<string, {order: number}>} found The keys seen, with their lowest order value.
+ * @param {Array<string|number>|undefined} listed An explicit order.
+ * @return {string[]} The ordered keys.
+ */
+function orderKeys(found, listed) {
+	const explicit = Array.isArray(listed) ? listed.map((k) => String(k)).filter((k) => found.has(k)) : []
+	const rest = [...found.keys()].filter((k) => !explicit.includes(k))
+	rest.sort((a, b) => {
+		const oa = found.get(a).order
+		const ob = found.get(b).order
+		if (oa !== ob) {
+			return oa - ob
+		}
+		return a.localeCompare(b, undefined, { numeric: true })
+	})
+	return [...explicit, ...rest]
+}
+
+/**
+ * Lay out cell records as matrix rows and columns.
+ *
+ * Config: `rowField`, `columnField`, `valueField` (paths on a record);
+ * optional `rowLabelField` / `columnLabelField` (a path holding the label),
+ * `rowLabels` / `columnLabels` (key to label maps, these win), `rowOrder` /
+ * `columnOrder` (keys in order) and `rowOrderField` / `columnOrderField` (a
+ * numeric path to sort by). A record without a row or column is skipped; when
+ * two records name the same cell, the first wins.
+ *
+ * @param {Array<object>} records The cell records.
+ * @param {object} config The `cellSource` config.
+ * @return {{series: Array<{key: string, name: string, data: Array<unknown>}>, categories: string[], columnKeys: string[]}} The matrix.
+ * @spec openspec/changes/matrix-cell-records/specs/matrix-cell-records/spec.md#requirement-a-matrix-can-read-its-cells-from-records
+ */
+export function pivotCells(records, config) {
+	const cfg = config && typeof config === 'object' ? config : {}
+	const rows = new Map()
+	const columns = new Map()
+	const cells = new Map()
+	const note = (map, key, label, order) => {
+		const entry = map.get(key)
+		const value = Number(order)
+		const rank = Number.isFinite(value) ? value : Infinity
+		if (!entry) {
+			map.set(key, { label, order: rank })
+		} else {
+			entry.order = Math.min(entry.order, rank)
+			entry.label = entry.label || label
+		}
+	}
+	for (const record of Array.isArray(records) ? records : []) {
+		if (!record || typeof record !== 'object') {
+			continue
+		}
+		const row = keyOf(readPath(record, cfg.rowField))
+		const column = keyOf(readPath(record, cfg.columnField))
+		if (row === null || column === null) {
+			continue
+		}
+		note(rows, row, cfg.rowLabelField ? keyOf(readPath(record, cfg.rowLabelField)) : null, cfg.rowOrderField ? readPath(record, cfg.rowOrderField) : undefined)
+		note(columns, column, cfg.columnLabelField ? keyOf(readPath(record, cfg.columnLabelField)) : null, cfg.columnOrderField ? readPath(record, cfg.columnOrderField) : undefined)
+		const cell = `${row}\u0000${column}`
+		if (!cells.has(cell)) {
+			const value = readPath(record, cfg.valueField)
+			cells.set(cell, value === undefined ? null : value)
+		}
+	}
+	const rowKeys = orderKeys(rows, cfg.rowOrder)
+	const columnKeys = orderKeys(columns, cfg.columnOrder)
+	const labelOf = (key, map, labels) => {
+		if (labels && typeof labels === 'object' && typeof labels[key] === 'string') {
+			return labels[key]
+		}
+		return map.get(key).label || key
+	}
+	return {
+		series: rowKeys.map((row) => ({
+			key: row,
+			name: labelOf(row, rows, cfg.rowLabels),
+			data: columnKeys.map((column) => {
+				const value = cells.get(`${row}\u0000${column}`)
+				return value === undefined ? null : value
+			}),
+		})),
+		categories: columnKeys.map((column) => labelOf(column, columns, cfg.columnLabels)),
+		columnKeys,
+	}
+}
+
+/**
+ * The cells of a matrix kept inside ONE record: the array at `cellsPath`,
+ * narrowed by `cellFilter` (field to value, compared as text), with the axis
+ * order read from `rowOrderPath` / `columnOrderPath` on the record when the
+ * config gives no `rowOrder` / `columnOrder` list.
+ *
+ * @param {object|null} record The record that holds the matrix.
+ * @param {object} config The `cellSource` config.
+ * @param {object} [cellFilter] The `cellFilter`, tokens already resolved.
+ * @return {{cells: Array<object>, config: object}} The cells, and the config to lay them out with.
+ * @spec openspec/changes/matrix-cell-records/specs/matrix-cell-records/spec.md#requirement-a-matrix-can-read-its-cells-from-one-record
+ */
+export function cellsFromRecord(record, config, cellFilter = {}) {
+	const cfg = config && typeof config === 'object' ? config : {}
+	const list = record ? readPath(record, cfg.cellsPath) : null
+	const wanted = Object.entries(cellFilter && typeof cellFilter === 'object' ? cellFilter : {})
+	const cells = (Array.isArray(list) ? list : []).filter((cell) => cell && typeof cell === 'object'
+		&& wanted.every(([field, value]) => keyOf(readPath(cell, field)) === keyOf(value)))
+	const axis = (path) => {
+		const value = record && path ? readPath(record, path) : null
+		return Array.isArray(value) ? value : undefined
+	}
+	return {
+		cells,
+		config: {
+			...cfg,
+			rowOrder: Array.isArray(cfg.rowOrder) ? cfg.rowOrder : axis(cfg.rowOrderPath),
+			columnOrder: Array.isArray(cfg.columnOrder) ? cfg.columnOrder : axis(cfg.columnOrderPath),
+		},
+	}
+}

package/src/utils/nextcloudDirectory.js

@@ -0,0 +1,117 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ */
+
+import { generateOcsUrl } from '@nextcloud/router'
+
+/**
+ * Nextcloud's own directory: groups, the users in a group, and whether a
+ * user is in today. Read through the OCS API with the reader's session, so
+ * Nextcloud decides what the reader may see (listing a group's members needs
+ * an admin or the group's sub-admin).
+ *
+ * @module utils/nextcloudDirectory
+ */
+
+const OCS_HEADERS = { 'OCS-APIRequest': 'true' }
+
+/**
+ * The `ocs.data` of an OCS response, or null.
+ *
+ * @param {object} res An axios response.
+ * @return {object|null}
+ */
+function ocsData(res) {
+	return (res && res.data && res.data.ocs && res.data.ocs.data) || null
+}
+
+/**
+ * The groups, with their member counts.
+ *
+ * @param {object} axios The axios instance.
+ * @param {{search?: string, limit?: number}} [options] Narrowing.
+ * @return {Promise<Array<{id: string, name: string, count: number}>>}
+ * @spec openspec/changes/index-groups-users-source/specs/index-page/spec.md#requirement-an-index-page-can-list-nextcloud-groups-and-their-members
+ */
+export async function fetchGroups(axios, options = {}) {
+	const res = await axios.get(generateOcsUrl('cloud/groups/details'), {
+		params: { search: options.search || '', limit: options.limit || 200, format: 'json' },
+		headers: OCS_HEADERS,
+	})
+	const groups = (ocsData(res) && ocsData(res).groups) || []
+	return groups.map((group) => ({
+		id: String(group.id),
+		name: group.displayname || String(group.id),
+		count: Number(group.usercount) || 0,
+	}))
+}
+
+/**
+ * The members of one group, with their details.
+ *
+ * @param {object} axios The axios instance.
+ * @param {string} groupId The group id.
+ * @return {Promise<Array<object>>} Nextcloud's user details, one per member.
+ * @spec openspec/changes/index-groups-users-source/specs/index-page/spec.md#requirement-an-index-page-can-list-nextcloud-groups-and-their-members
+ */
+export async function fetchGroupMembers(axios, groupId) {
+	const res = await axios.get(generateOcsUrl('cloud/groups/{groupId}/users/details', { groupId }), {
+		params: { format: 'json' },
+		headers: OCS_HEADERS,
+	})
+	const users = (ocsData(res) && ocsData(res).users) || {}
+	return Array.isArray(users) ? users : Object.values(users)
+}
+
+/**
+ * Whether a user is in today: an out-of-office period that runs now (the
+ * dav app's absence, Nextcloud 28 and later), else their user status.
+ *
+ * @param {object} axios The axios instance.
+ * @param {string} userId The user id.
+ * @param {object|null} status The user's entry from the user status list, or null.
+ * @return {Promise<{state: string, until: (string|null), message: string}>}
+ *   `state` is `absent` (with `until`, an ISO date), `away`, `present` or `unknown`.
+ * @spec openspec/changes/index-groups-users-source/specs/index-page/spec.md#requirement-an-index-page-can-list-nextcloud-groups-and-their-members
+ */
+export async function fetchPresence(axios, userId, status) {
+	try {
+		const res = await axios.get(generateOcsUrl('apps/dav/api/v1/outOfOffice/{userId}/now', { userId }), { params: { format: 'json' }, headers: OCS_HEADERS })
+		const ooo = ocsData(res)
+		if (ooo && ooo.endDate) {
+			const end = typeof ooo.endDate === 'number' ? new Date(ooo.endDate * 1000) : new Date(ooo.endDate)
+			return { state: 'absent', until: Number.isNaN(end.getTime()) ? null : end.toISOString().slice(0, 10), message: ooo.shortMessage || '' }
+		}
+	} catch {
+		// 404: no absence now, or an instance without the absence API.
+	}
+	if (status && typeof status === 'object') {
+		const message = typeof status.message === 'string' ? status.message : ''
+		if (status.status === 'online') {
+			return { state: 'present', until: null, message }
+		}
+		if (status.status === 'away' || status.status === 'dnd') {
+			return { state: 'away', until: null, message }
+		}
+	}
+	return { state: 'unknown', until: null, message: '' }
+}
+
+/**
+ * The user statuses Nextcloud shares with the reader, by user id. Empty when
+ * the user status app is off.
+ *
+ * @param {object} axios The axios instance.
+ * @return {Promise<Record<string, object>>}
+ * @spec openspec/changes/index-groups-users-source/specs/index-page/spec.md#requirement-an-index-page-can-list-nextcloud-groups-and-their-members
+ */
+export async function fetchStatuses(axios) {
+	try {
+		const res = await axios.get(generateOcsUrl('apps/user_status/api/v1/statuses'), { params: { limit: 500, format: 'json' }, headers: OCS_HEADERS })
+		const list = ocsData(res) || []
+		return Object.fromEntries((Array.isArray(list) ? list : []).map((entry) => [entry.userId, entry]))
+	} catch {
+		return {}
+	}
+}