@conduction/nextcloud-vue 2.79.0 → 2.81.0

package/src/utils/facets.js

@@ -37,14 +37,29 @@ export function normalizeFacetBucket(bucket) {
 	return option
 }
 
+/**
+ * The option id that stands for "this property holds no value".
+ *
+ * Chosen so no real bucket key can collide with it. Selecting it is sent to
+ * OpenRegister as `<property>_isnull=true` by {@link facetFilterParams}.
+ *
+ * @type {string}
+ */
+export const MISSING_VALUE = '__cn_missing__'
+
 /**
  * Normalise the `facets` block of a collection response into sidebar format.
  *
  * Fields whose facet carries no bucket list are skipped entirely, so a caller
  * can tell an unfaceted field from one that faceted to nothing.
  *
+ * What OpenRegister puts beside the buckets is carried through rather than
+ * dropped: `missing` (how many objects in scope hold no value, sent as
+ * `{ results }` or `{ count }`), `type` and `title`. A missing count is only
+ * set when the backend sent one, for the same reason a bucket count is.
+ *
  * @param {object} facets The `facets` block of an API response
- * @return {object} `{ fieldName: { values: [{ value, count?, label? }] } }`
+ * @return {object} `{ fieldName: { values: [{ value, count?, label? }], missing?, type?, title? } }`
  */
 export function normalizeFacets(facets) {
 	const transformed = {}
@@ -54,12 +69,69 @@ export function normalizeFacets(facets) {
 		if (!buckets) {
 			continue
 		}
-		transformed[key] = { values: buckets.map(normalizeFacetBucket) }
+		const normalized = { values: buckets.map(normalizeFacetBucket) }
+
+		const missing = facet.missing?.results ?? facet.missing?.count
+		if (typeof missing === 'number') {
+			normalized.missing = missing
+		}
+		for (const name of ['type', 'title']) {
+			if (facet[name] !== undefined && facet[name] !== null) {
+				normalized[name] = facet[name]
+			}
+		}
+
+		transformed[key] = normalized
 	}
 
 	return transformed
 }
 
+/**
+ * The sidebar options for one normalised facet, with the missing-value option
+ * appended when some objects hold no value.
+ *
+ * @param {object|undefined} facet        A normalised facet from {@link normalizeFacets}
+ * @param {function(number): string} missingLabel Renders the missing option's label from its count
+ * @return {Array<{id: unknown, label: string}>|null} The options, or null when the
+ *   facet offers nothing, so the caller can fall back to its static options
+ */
+export function facetOptions(facet, missingLabel) {
+	const options = (facet?.values || []).map((v) => ({
+		id: v.value,
+		label: facetOptionLabel(v),
+	}))
+
+	if (typeof facet?.missing === 'number' && facet.missing > 0) {
+		options.push({ id: MISSING_VALUE, label: missingLabel(facet.missing) })
+	}
+
+	return options.length > 0 ? options : null
+}
+
+/**
+ * The query parameters one facet selection sends.
+ *
+ * An ordinary selection is the property itself, one value unwrapped and
+ * several as a list. The missing-value option is exclusive: no object both
+ * holds one of the chosen values and holds none, so combining them would
+ * always answer an empty list. It is sent as `<property>_isnull=true`.
+ *
+ * @param {string} key      The filtered property
+ * @param {Array} values    The selected option ids
+ * @return {object} The parameters to merge into the request
+ */
+export function facetFilterParams(key, values) {
+	if (!Array.isArray(values) || values.length === 0) {
+		return {}
+	}
+	if (values.includes(MISSING_VALUE)) {
+		return { [`${key}_isnull`]: 'true' }
+	}
+
+	return { [key]: values.length === 1 ? values[0] : values }
+}
+
 /**
  * Build the visible label for one faceted filter option.
  *

package/src/utils/fetchFilterCounts.js

@@ -9,8 +9,9 @@
  * `status: closed`, ...). Those are answered by one `/grouped` request on that
  * field. A filter that narrows on something else (two fields, an operator, a
  * list of values) cannot be read off a grouped result, so each of those costs
- * one `/value` count. A filter that holds a LIST of values is counted through
- * the list endpoint, because the aggregation endpoints cannot express it.
+ * one `/value` count. A filter that holds a LIST of values, or tests a field
+ * for no value (`isnull`), is counted through the list endpoint, because the
+ * aggregation endpoints cannot express it.
  * Nothing is requested for an entry that did not ask.
  *
  * @module utils/fetchFilterCounts
@@ -38,6 +39,37 @@ export function hasListValue(filter) {
 	return Object.values(filter).some((value) => Array.isArray(value))
 }
 
+/**
+ * Whether a filter tests a field for "no value" (`{ assignee: null }` or
+ * `{ supersededBy: { isnull: true } }`).
+ *
+ * OpenRegister's aggregation endpoints have no null operator: `isnull` is
+ * refused there and an empty value is dropped or matches nothing, so such a
+ * filter counted 0 while the list showed rows. The list endpoint does read
+ * `field[isnull]=true`, so a filter like this is counted through it.
+ *
+ * @param {object} filter A filter map.
+ * @return {boolean} True when any value is null or carries an `isnull` operator.
+ */
+export function hasNullTest(filter) {
+	if (!filter || typeof filter !== 'object') {
+		return false
+	}
+	return Object.values(filter).some((value) => value === null
+		|| (value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).some((op) => op.toLowerCase() === 'isnull')))
+}
+
+/**
+ * Whether the aggregation endpoints cannot express a filter, so it is counted
+ * through the list endpoint: a list of values, or a test for no value.
+ *
+ * @param {object} filter A filter map.
+ * @return {boolean} True when the filter needs the list endpoint.
+ */
+export function needsListEndpoint(filter) {
+	return hasListValue(filter) || hasNullTest(filter)
+}
+
 /**
  * Count the records a filter matches by asking the LIST endpoint for one
  * record and reading its `total`. The filter is sent the way the list request
@@ -59,6 +91,9 @@ export async function fetchListTotal(register, schema, filter, ctx) {
 			for (const [op, operand] of Object.entries(value)) {
 				params[`${key}[${op}]`] = operand
 			}
+		} else if (value === null) {
+			// "No value": the list endpoint reads it as the isnull operator.
+			params[`${key}[isnull]`] = 'true'
 		} else {
 			params[key] = value
 		}
@@ -125,12 +160,12 @@ export async function fetchFilterCounts({ register, schema, entries, baseFilter,
 	// and `/value` returns exactly its number.
 	// A list of values anywhere in a request rules the aggregation endpoints
 	// out for it. A base filter with one rules them out for every entry.
-	const baseHasList = hasListValue(base)
+	const baseHasList = needsListEndpoint(base)
 	const byField = {}
 	const single = []
 	const viaList = []
 	for (const entry of entries) {
-		if (baseHasList || hasListValue(entry.filter)) {
+		if (baseHasList || needsListEndpoint(entry.filter)) {
 			viaList.push(entry)
 			continue
 		}

package/src/utils/fillTemplate.js

@@ -0,0 +1,116 @@
+// SPDX-FileCopyrightText: 2026 Conduction B.V.
+// SPDX-License-Identifier: EUPL-1.2
+
+import { boardDateLocale, formatBoardDate } from './boardDate.js'
+import { parseDateValue } from './dateVariant.js'
+import { readPath } from './readPath.js'
+
+const TOKEN = /\{([^{}\s|]+)(?:\|([a-z]+))?\}/g
+
+/**
+ * A moment in the board's short form with the time: "4 okt, 10:52", or
+ * "14 feb 2024, 09:00" outside the current year.
+ *
+ * @param {unknown} value A Date, a timestamp or an ISO string.
+ * @param {Date} [now] The reference moment.
+ * @return {string} The text, or '' when the value is not a date.
+ * @spec openspec/changes/screens-relation-pages/specs/relation-pages/spec.md#requirement-a-record-list-shows-the-objects-that-point-at-this-record
+ */
+export function formatBoardDateTime(value, now = new Date()) {
+	const day = formatBoardDate(value, now)
+	const date = parseDateValue(value)
+	if (day === '' || date === null) {
+		return ''
+	}
+	let time
+	try {
+		time = new Intl.DateTimeFormat(boardDateLocale(), { hour: '2-digit', minute: '2-digit' }).format(date)
+	} catch {
+		time = new Intl.DateTimeFormat(undefined, { hour: '2-digit', minute: '2-digit' }).format(date)
+	}
+	return `${day}, ${time}`
+}
+
+/**
+ * Format one token value.
+ *
+ * @param {unknown} value The raw value.
+ * @param {string} format `date`, `datetime` or '' (as is).
+ * @param {Date} now The reference moment.
+ * @return {string} The text, '' when nothing can be shown.
+ */
+function formatValue(value, format, now) {
+	if (value === null || value === undefined || value === '' || typeof value === 'object') {
+		return ''
+	}
+	if (format === 'date') {
+		return formatBoardDate(value, now)
+	}
+	if (format === 'datetime') {
+		return formatBoardDateTime(value, now)
+	}
+	if (format === 'days') {
+		// Whole days from the date to now (0 for today; negative for a future date).
+		const date = parseDateValue(value)
+		return date === null ? '' : String(Math.floor((now.getTime() - date.getTime()) / 86400000))
+	}
+	return String(value)
+}
+
+/**
+ * Fill a row template such as `"{identifier} · {caseTypeName}"` or
+ * `"Termijn {deadline|date}"` from an object.
+ *
+ * Every `{path}` token is a dot path into the object; `{path|date}` and
+ * `{path|datetime}` format it as the boards write dates, and `{path|days}` is the
+ * whole days since that date ("has waited {createdAt|days} days"). A token without a
+ * value empties the WHOLE template, because "Termijn " is worse than nothing.
+ * A template without tokens is returned as written (a constant label).
+ *
+ * @param {string} template The template, already translated.
+ * @param {object|null} object The object to read.
+ * @param {Date} [now] The reference moment for dates.
+ * @return {string} The filled text, or ''.
+ * @spec openspec/changes/screens-relation-pages/specs/relation-pages/spec.md#requirement-a-record-list-shows-the-objects-that-point-at-this-record
+ */
+export function fillTemplate(template, object, now = new Date()) {
+	if (typeof template !== 'string' || template.trim() === '') {
+		return ''
+	}
+	let missing = false
+	const text = template.replace(TOKEN, (_match, path, format) => {
+		const value = object && typeof object === 'object' ? readPath(object, path) : undefined
+		const shown = formatValue(value, format || '', now)
+		if (shown === '') {
+			missing = true
+		}
+		return shown
+	})
+	return missing ? '' : text.trim()
+}
+
+/**
+ * The first of several templates that fills: `["Klaar {closedAt|date}",
+ * "Termijn {deadline|date}"]` reads "Klaar ..." once the case is closed and
+ * "Termijn ..." while it is open. A single string is one candidate.
+ *
+ * @param {string|string[]} templates The candidates, in order.
+ * @param {object|null} object The object to read.
+ * @param {(key: string) => string} [translate] Applied to each template before filling.
+ * @param {Date} [now] The reference moment for dates.
+ * @return {string} The first filled text, or ''.
+ * @spec openspec/changes/screens-relation-pages/specs/relation-pages/spec.md#requirement-a-record-list-shows-the-objects-that-point-at-this-record
+ */
+export function firstFilled(templates, object, translate = (key) => key, now = new Date()) {
+	const list = Array.isArray(templates) ? templates : [templates]
+	for (const template of list) {
+		if (typeof template !== 'string') {
+			continue
+		}
+		const text = fillTemplate(translate(template), object, now)
+		if (text !== '') {
+			return text
+		}
+	}
+	return ''
+}

package/src/utils/initials.js

@@ -0,0 +1,29 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * initials: the letters an avatar shows for a free name.
+ *
+ * @module utils/initials
+ */
+
+/**
+ * The initials of a name: the first letters of its first and its last word,
+ * upper-cased ("Sanne de Vries" reads "SV", "Jan" reads "J").
+ *
+ * @param {unknown} name The name.
+ * @return {string} One or two letters, or '' when there is no name.
+ * @spec openspec/changes/screens-record-list-avatar/specs/record-list-avatar/spec.md#requirement-a-record-list-row-can-carry-an-avatar
+ */
+export function initialsOf(name) {
+	if (typeof name !== 'string') {
+		return ''
+	}
+	const words = name.trim().split(/\s+/).filter((word) => word !== '')
+	if (words.length === 0) {
+		return ''
+	}
+	const first = Array.from(words[0])[0] || ''
+	const last = words.length > 1 ? (Array.from(words[words.length - 1])[0] || '') : ''
+	return (first + last).toLocaleUpperCase()
+}

package/src/utils/libraryWidgetKeys.js

@@ -93,6 +93,8 @@ export const DASHBOARD_CATALOG_WIDGET_KEYS = Object.freeze([
 	'banner',
 	'calendar',
 	'chart',
+	'chips-field',
+	'choice-picker',
 	'container',
 	'conversation',
 	'countdown',
@@ -100,6 +102,8 @@ export const DASHBOARD_CATALOG_WIDGET_KEYS = Object.freeze([
 	'delta',
 	'divider',
 	'document-review',
+	'facts',
+	'field-list',
 	'files',
 	'flow-runs',
 	'gauge',
@@ -123,19 +127,26 @@ export const DASHBOARD_CATALOG_WIDGET_KEYS = Object.freeze([
 	'object-table',
 	'people',
 	'quicklinks',
+	'radio-cards',
+	'record-list',
 	'related',
 	'saved-view',
+	'saved-views',
+	'sections',
+	'settings-form',
 	'spend-analytics',
 	'stacked-bar',
 	'stages',
 	'stat',
 	'stats-block',
+	'switch-rows',
 	'table',
 	'tabs',
 	'tasks',
 	'text',
 	'tile',
 	'timeline',
+	'toggle-table',
 	'video',
 	'week-strip',
 	'workspace-filter',

package/src/utils/objectWrite.js

@@ -0,0 +1,55 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * objectWrite: the one-object PATCH the settings widgets share.
+ *
+ * @module utils/objectWrite
+ */
+
+import { prefixUrl } from './headers.js'
+
+/**
+ * The OpenRegister URL of one object, or '' when register, schema or id is missing.
+ *
+ * @param {string|object} register Register slug.
+ * @param {string|object} schema Schema slug.
+ * @param {string|number} id Object id.
+ * @return {string} The object URL.
+ */
+export function objectUrlOf(register, schema, id) {
+	if (typeof register !== 'string' || typeof schema !== 'string' || !register || !schema || id === undefined || id === null || id === '') {
+		return ''
+	}
+	return `/apps/openregister/api/objects/${encodeURIComponent(register)}/${encodeURIComponent(schema)}/${encodeURIComponent(String(id))}`
+}
+
+/**
+ * PATCH only the given fields of one object.
+ *
+ * @param {string} url The object URL (see objectUrlOf).
+ * @param {object} patch The fields to write.
+ * @return {Promise<object>} The object the server answered with.
+ */
+export async function patchObject(url, patch) {
+	const { default: axios } = await import('@nextcloud/axios')
+	const { data } = await axios.patch(prefixUrl(url), patch)
+	return data && typeof data === 'object' ? data : {}
+}
+
+/**
+ * The fields of `next` that differ from `base`, compared by value.
+ *
+ * @param {object} base What the server last held.
+ * @param {object} next What the form holds.
+ * @return {object} The changed fields only.
+ */
+export function changedFields(base, next) {
+	const patch = {}
+	for (const [key, value] of Object.entries(next)) {
+		if (JSON.stringify(value === undefined ? null : value) !== JSON.stringify(base[key] === undefined ? null : base[key])) {
+			patch[key] = value
+		}
+	}
+	return patch
+}

package/src/utils/pageControls.js

@@ -0,0 +1,78 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * pageControls: how a list widget listens to the page's controls.
+ *
+ * A page control (a `workspace-filter` select or switch) writes a value to the
+ * page workspace. A list widget declares which control it listens to and what
+ * the value means for it:
+ *
+ *   pageControls: {
+ *     sort:   { key: "sort", map: { deadline: { field: "slaDeadline", dir: "asc" } } },
+ *     toggle: { key: "showDone", removes: ["status"] }
+ *   }
+ *
+ * `sort`: the workspace value at `key` picks an entry of `map` (the sort the
+ * list uses); a value with no entry leaves the list's own sort.
+ * `toggle`: while the workspace value at `key` is on (true, "1", "true"), the
+ * filter keys in `removes` are dropped, so a list that hides finished work
+ * shows it.
+ *
+ * @module utils/pageControls
+ */
+
+/**
+ * Whether a workspace value reads as on.
+ *
+ * @param {unknown} value The value.
+ * @return {boolean} True for true, 1, "1" and "true".
+ */
+export function isOn(value) {
+	return value === true || value === 1 || value === '1' || value === 'true'
+}
+
+/**
+ * The sort a list uses once the page's sort control is read.
+ *
+ * @param {object|null} pageControls The widget's `pageControls`.
+ * @param {object} workspace The plain workspace bag.
+ * @param {{field: string, dir?: string}|null} own The list's own sort.
+ * @return {{field: string, dir?: string}|null} The sort to use.
+ * @spec openspec/changes/screens-page-controls/specs/page-controls/spec.md#requirement-a-list-listens-to-the-pages-controls
+ */
+export function pageSort(pageControls, workspace, own) {
+	const listen = pageControls && typeof pageControls === 'object' ? pageControls.sort : null
+	if (!listen || typeof listen.key !== 'string' || !listen.map || typeof listen.map !== 'object') {
+		return own
+	}
+	const chosen = workspace ? workspace[listen.key] : undefined
+	const entry = chosen !== undefined && chosen !== null ? listen.map[String(chosen)] : null
+	return entry && typeof entry === 'object' && typeof entry.field === 'string' && entry.field !== '' ? entry : own
+}
+
+/**
+ * The filter a list uses once the page's toggle is read: with the toggle on,
+ * the keys it `removes` are gone.
+ *
+ * @param {object|null} pageControls The widget's `pageControls`.
+ * @param {object} workspace The plain workspace bag.
+ * @param {object} filter The list's own filter (before token resolution).
+ * @return {object} The filter to use (the same object when nothing is removed).
+ * @spec openspec/changes/screens-page-controls/specs/page-controls/spec.md#requirement-a-list-listens-to-the-pages-controls
+ */
+export function pageFilter(pageControls, workspace, filter) {
+	const listen = pageControls && typeof pageControls === 'object' ? pageControls.toggle : null
+	const base = filter && typeof filter === 'object' ? filter : {}
+	if (!listen || typeof listen.key !== 'string' || !Array.isArray(listen.removes)) {
+		return base
+	}
+	if (!isOn(workspace ? workspace[listen.key] : undefined)) {
+		return base
+	}
+	const out = { ...base }
+	for (const key of listen.removes) {
+		delete out[key]
+	}
+	return out
+}

package/src/utils/personalLenses.js

@@ -37,6 +37,42 @@ export function personalLensTabs(lenses) {
 		.map((id) => ({ label: labels[id], filter: { [LENS_FILTER_KEYS[id]]: true }, lens: id }))
 }
 
+/**
+ * Turn the `empty` / `notEmpty` shorthand of quick filters into a filter.
+ *
+ * `{ label: "Not logged in yet", empty: "lastLoginAt" }` is the rows where the
+ * field has no value: the filter `{ lastLoginAt: { isnull: true } }`, which
+ * OpenRegister reads as `lastLoginAt[isnull]=true`. `notEmpty` is the rows
+ * where it has one. Either takes a field or a list of fields and merges with
+ * the entry's own `filter`. Returns the same array when no entry uses it.
+ *
+ * @param {Array<object>|null} quickFilters The page's quick filters.
+ * @return {Array<object>|null} The quick filters with the shorthand expanded.
+ */
+export function expandEmptyFilters(quickFilters) {
+	if (!Array.isArray(quickFilters)) {
+		return quickFilters
+	}
+	const uses = (tab) => tab && typeof tab === 'object' && (tab.empty || tab.notEmpty)
+	if (!quickFilters.some(uses)) {
+		return quickFilters
+	}
+	const fieldsOf = (value) => (Array.isArray(value) ? value : [value]).filter((f) => typeof f === 'string' && f !== '')
+	return quickFilters.map((tab) => {
+		if (!uses(tab)) {
+			return tab
+		}
+		const filter = { ...(tab.filter && typeof tab.filter === 'object' ? tab.filter : {}) }
+		for (const field of fieldsOf(tab.empty)) {
+			filter[field] = { isnull: true }
+		}
+		for (const field of fieldsOf(tab.notEmpty)) {
+			filter[field] = { isnull: false }
+		}
+		return { ...tab, filter }
+	})
+}
+
 /**
  * The page's quick filters with its personal lenses appended. A page with no
  * quick filters of its own gets an "All" tab first, so a lens is not active
@@ -48,10 +84,11 @@ export function personalLensTabs(lenses) {
  */
 export function withPersonalLenses(quickFilters, lenses) {
 	const tabs = personalLensTabs(lenses)
+	const expanded = expandEmptyFilters(quickFilters)
 	if (tabs.length === 0) {
-		return quickFilters
+		return expanded
 	}
-	const own = Array.isArray(quickFilters) ? quickFilters : []
+	const own = Array.isArray(expanded) ? expanded : []
 	return own.length > 0
 		? [...own, ...tabs]
 		: [{ label: t('nextcloud-vue', 'All'), filter: {}, default: true }, ...tabs]

package/src/utils/queryPresets.js

@@ -0,0 +1,93 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * Query presets of an index page (`config.queryPresets`): a menu entry that
+ * deep-links to a list with a query (`{ caseType: '<uuid>' }`, the shape hydra
+ * gate-68 asks for instead of a second page) can bring its own lenses,
+ * columns and copy. The page names, per preset, the query it answers to and
+ * the keys it replaces; the first preset whose every `match` pair is in the
+ * current route query wins.
+ *
+ * @module utils/queryPresets
+ * @spec openspec/changes/screens-index-query-presets/specs/index-query-presets/spec.md#requirement-a-query-preset-overlays-lenses-columns-and-copy
+ */
+
+/**
+ * The config keys a preset may replace. Anything else in a preset is ignored:
+ * a preset changes what the list shows, never which register or schema it
+ * reads or what it may write.
+ *
+ * @type {ReadonlyArray<string>}
+ */
+export const QUERY_PRESET_KEYS = Object.freeze([
+	'title',
+	'quickFilters',
+	'columns',
+	'cardFields',
+	'countText',
+	'searchPlaceholder',
+	'footerNote',
+	'defaultSort',
+	'viewSwitch',
+])
+
+/**
+ * Whether one route query value satisfies one `match` value. A repeated query
+ * parameter (an array) matches when it holds the value.
+ *
+ * @param {unknown} actual The route query value.
+ * @param {string|number|boolean} expected The preset's value.
+ * @return {boolean} True when they match.
+ */
+function queryValueMatches(actual, expected) {
+	const want = String(expected)
+	if (Array.isArray(actual)) {
+		return actual.some((v) => String(v) === want)
+	}
+	return actual !== undefined && actual !== null && String(actual) === want
+}
+
+/**
+ * The index of the first preset whose every `match` pair is in the query.
+ * A preset without a non-empty `match` never matches.
+ *
+ * @param {Array<object>} presets The page's `queryPresets`.
+ * @param {object} query The current route query.
+ * @return {number} The preset index, or -1.
+ */
+export function matchQueryPreset(presets, query) {
+	if (!Array.isArray(presets)) {
+		return -1
+	}
+	const q = query && typeof query === 'object' ? query : {}
+	return presets.findIndex((preset) => {
+		const match = preset && typeof preset.match === 'object' && preset.match !== null ? preset.match : null
+		if (!match || Object.keys(match).length === 0) {
+			return false
+		}
+		return Object.entries(match).every(([key, value]) => queryValueMatches(q[key], value))
+	})
+}
+
+/**
+ * The page config with the preset's allowed keys laid over it, and without
+ * `queryPresets` itself (the page component has no such prop).
+ *
+ * @param {object} config The page config.
+ * @param {object|null} preset The matched preset, or null.
+ * @return {object} The effective config.
+ */
+export function applyQueryPreset(config, preset) {
+	const { queryPresets, ...rest } = config || {}
+	if (!preset || typeof preset !== 'object') {
+		return rest
+	}
+	const out = { ...rest }
+	for (const key of QUERY_PRESET_KEYS) {
+		if (key !== 'title' && preset[key] !== undefined) {
+			out[key] = preset[key]
+		}
+	}
+	return out
+}

package/src/utils/resolveFilterTokens.js

@@ -22,6 +22,10 @@
  *  - `@today±Nd`          → relative-date arithmetic at day granularity: N days
  *                           from today (e.g. `@today-30d`, `@today+7d`)
  *  - `@monthStart`        → first day of the current month, `YYYY-MM-DD`
+ *  - `@monthEnd`          → last day of the current month, `YYYY-MM-DD`; on a
+ *                           date-time field use `lt: '@nextMonthStart'` instead,
+ *                           since `lte` a date stops at that day's midnight
+ *  - `@nextMonthStart`    → first day of the next month, `YYYY-MM-DD`
  *  - `@quarterStart`      → first day of the current quarter, `YYYY-MM-DD`
  *  - `@yearStart`         → first day of the current year, `YYYY-MM-DD`
  *  - `@currentFiscalYear` → the current calendar year as a number string, e.g. `2026`
@@ -63,7 +67,9 @@
 
 import { getCurrentUser } from '@nextcloud/auth'
 import { TODAY_DELTA_RE } from './sentinelTokens.js'
-import { peekCurrentUserGroups } from './widgetVisibility.js'
+// userGroupsPeek, not widgetVisibility: that one imports @nextcloud/axios, and
+// this resolver runs on public pages and in node (see userGroupsPeek.js).
+import { peekCurrentUserGroups } from './userGroupsPeek.js'
 
 /** The filter token for the current user's group ids. */
 export const MY_GROUPS_TOKEN = '@myGroups'
@@ -214,6 +220,13 @@ export function resolveFilterValue(v, ctx) {
 	if (v === '@monthStart') {
 		return ymd(new Date(now.getFullYear(), now.getMonth(), 1))
 	}
+	if (v === '@monthEnd') {
+		// Day 0 of the next month is the last day of this one.
+		return ymd(new Date(now.getFullYear(), now.getMonth() + 1, 0))
+	}
+	if (v === '@nextMonthStart') {
+		return ymd(new Date(now.getFullYear(), now.getMonth() + 1, 1))
+	}
 	if (v === '@quarterStart') {
 		return ymd(new Date(now.getFullYear(), Math.floor(now.getMonth() / 3) * 3, 1))
 	}