@conduction/nextcloud-vue 2.59.0 → 2.61.0

package/src/utils/detailActionModel.js

@@ -0,0 +1,256 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * detailActionModel: the rules behind a detail page's four action levels and
+ * the case surfaces that read the record's stage.
+ *
+ *   1. the next step: one primary button, chosen by the record's stage,
+ *   2. quick actions: at most three always visible buttons,
+ *   3. the overflow menu: the rest, in named groups,
+ *   4. admin actions: the last group, for admins only.
+ *
+ * Pure functions, no Vue and no fetch, so CnDetailPage, the widgets and the
+ * tests all read one implementation.
+ *
+ * @module utils/detailActionModel
+ */
+
+import { readPath } from './readPath.js'
+import { evaluateVisibleWhenLocal } from './visibleWhen.js'
+
+/** The most quick actions a page shows. Later entries are dropped. */
+export const MAX_QUICK_ACTIONS = 3
+
+/**
+ * The record's stage, as the string a stage map is keyed on.
+ *
+ * @param {object|null} object The record.
+ * @param {string} [stageField] Dot-path to the stage. Defaults to `status`.
+ * @return {string} The stage, or '' when the record has none.
+ * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-primary-action-follows-the-stage
+ */
+export function stageOf(object, stageField = 'status') {
+	if (!object || typeof object !== 'object') {
+		return ''
+	}
+	const value = readPath(object, stageField || 'status')
+	if (value === null || value === undefined || typeof value === 'object') {
+		return ''
+	}
+	return String(value)
+}
+
+/**
+ * Look a stage up in a stage-keyed map. An exact key wins; otherwise the
+ * match ignores case, because a status is stored as `in_behandeling` in one
+ * register and `In_Behandeling` in the next.
+ *
+ * @param {object|null} map The stage-keyed map.
+ * @param {string} stage The stage.
+ * @return {unknown} The entry, or undefined.
+ * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-primary-action-follows-the-stage
+ */
+export function stageEntry(map, stage) {
+	if (!map || typeof map !== 'object' || Array.isArray(map) || stage === '') {
+		return undefined
+	}
+	if (Object.hasOwn(map, stage)) {
+		return map[stage]
+	}
+	const wanted = stage.toLowerCase()
+	const key = Object.keys(map).find((candidate) => candidate.toLowerCase() === wanted)
+	return key === undefined ? undefined : map[key]
+}
+
+/**
+ * Turn a pinned action entry into a descriptor the page can dispatch.
+ *
+ * An entry is the id of a declared header action, or an action object of its
+ * own. An object without an id gets `fallbackId`, since every dispatched
+ * action is addressed by id.
+ *
+ * @param {string|object|null} entry The entry.
+ * @param {string} fallbackId Id for an inline action that names none.
+ * @return {{id: string, inline: object|null}|null} The id, plus the inline definition when the entry carried one.
+ * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-quick-actions
+ */
+export function normalisePinnedAction(entry, fallbackId) {
+	if (typeof entry === 'string') {
+		return entry === '' ? null : { id: entry, inline: null }
+	}
+	if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+		return null
+	}
+	if (typeof entry.label !== 'string' || entry.label === '') {
+		return null
+	}
+	const id = typeof entry.id === 'string' && entry.id !== '' ? entry.id : fallbackId
+	return { id, inline: { ...entry, id } }
+}
+
+/**
+ * Split menu entries into the groups the overflow menu draws.
+ *
+ * Ungrouped entries come first, under no caption. Named groups follow in the
+ * order they first appear. Admin only entries are dropped for everyone else
+ * and form the last group for admins, whatever `group` they also name.
+ *
+ * `adminOnly` hides a control. It is never an authorization decision: the
+ * endpoint behind the action decides who may call it.
+ *
+ * @param {Array<object>} entries Menu-ready entries, each with an `id`.
+ * @param {object} actionsById The declared actions by id, carrying `group` / `adminOnly`.
+ * @param {{isAdmin?: boolean, adminLabel?: string}} [options] Who is looking, and what the admin group is called.
+ * @return {Array<{key: string, label: string, entries: Array<object>}>} The non-empty groups, in render order.
+ * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-grouped-and-admin-only-menu-actions
+ */
+export function groupMenuEntries(entries, actionsById = {}, options = {}) {
+	const isAdmin = options.isAdmin === true
+	const plain = { key: '', label: '', entries: [] }
+	const named = []
+	const admin = { key: 'cn-admin', label: options.adminLabel || '', entries: [] }
+	for (const entry of Array.isArray(entries) ? entries : []) {
+		const declared = (entry && actionsById[entry.id]) || {}
+		if (declared.adminOnly === true) {
+			if (isAdmin) {
+				admin.entries.push(entry)
+			}
+			continue
+		}
+		const label = typeof declared.group === 'string' ? declared.group.trim() : ''
+		if (label === '') {
+			plain.entries.push(entry)
+			continue
+		}
+		let group = named.find((candidate) => candidate.label === label)
+		if (!group) {
+			group = { key: `cn-group-${named.length}`, label, entries: [] }
+			named.push(group)
+		}
+		group.entries.push(entry)
+	}
+	return [plain, ...named, admin].filter((group) => group.entries.length > 0)
+}
+
+/**
+ * Whether one checklist item is done for this record.
+ *
+ * `done` (a literal) wins, then `doneWhen` (a local visibleWhen condition),
+ * then `doneField` (truthy, and for a list: not empty).
+ *
+ * @param {object} item The checklist item.
+ * @param {object|null} object The record.
+ * @return {boolean} True when the item is done.
+ * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-next-step-card
+ */
+export function isChecklistItemDone(item, object) {
+	if (!item || typeof item !== 'object') {
+		return false
+	}
+	if (typeof item.done === 'boolean') {
+		return item.done
+	}
+	const data = object && typeof object === 'object' ? object : {}
+	if (item.doneWhen && typeof item.doneWhen === 'object') {
+		return evaluateVisibleWhenLocal(item.doneWhen, data)
+	}
+	if (typeof item.doneField === 'string' && item.doneField !== '') {
+		const value = readPath(data, item.doneField)
+		return Array.isArray(value) ? value.length > 0 : Boolean(value)
+	}
+	return false
+}
+
+/**
+ * Resolve the "what now" card for the record's stage.
+ *
+ * @param {{stages?: object, title?: string}|null} config The `nextStep` config.
+ * @param {object|null} object The record.
+ * @param {string} [stageField] Dot-path to the stage.
+ * @return {{stage: string, title: string, items: Array<{label: string, done: boolean, hint: string}>, after: string}|null} The card, or null when this stage declares no checklist.
+ * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-next-step-card
+ */
+export function resolveNextStep(config, object, stageField = 'status') {
+	if (!config || typeof config !== 'object') {
+		return null
+	}
+	const stage = stageOf(object, config.field || stageField)
+	const declared = stageEntry(config.stages, stage)
+	if (!declared || typeof declared !== 'object' || !Array.isArray(declared.checklist)) {
+		return null
+	}
+	const items = declared.checklist
+		.filter((item) => item && typeof item === 'object' && typeof item.label === 'string' && item.label !== '')
+		.map((item) => ({
+			label: item.label,
+			done: isChecklistItemDone(item, object),
+			hint: typeof item.hint === 'string' ? item.hint : '',
+		}))
+	if (items.length === 0) {
+		return null
+	}
+	return {
+		stage,
+		title: typeof declared.title === 'string' ? declared.title : (typeof config.title === 'string' ? config.title : ''),
+		items,
+		after: typeof declared.after === 'string' ? declared.after : '',
+	}
+}
+
+/**
+ * Resolve a header pill from the record.
+ *
+ * @param {{field?: string, colorMap?: object, labels?: object, variant?: string}|null} config The pill config.
+ * @param {object|null} object The record.
+ * @return {{label: string, colorKey: string, colorMap: object|null, variant: string}|null} What CnStatusBadge needs, or null when the field is empty.
+ * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-header-pills
+ */
+export function resolvePill(config, object) {
+	if (!config || typeof config !== 'object' || typeof config.field !== 'string' || config.field === '') {
+		return null
+	}
+	const raw = stageOf(object, config.field)
+	if (raw === '') {
+		return null
+	}
+	const mapped = stageEntry(config.labels, raw)
+	return {
+		label: typeof mapped === 'string' && mapped !== '' ? mapped : raw,
+		colorKey: raw,
+		colorMap: config.colorMap && typeof config.colorMap === 'object' ? config.colorMap : null,
+		variant: typeof config.variant === 'string' && config.variant !== '' ? config.variant : 'default',
+	}
+}
+
+/**
+ * Resolve a tab's count.
+ *
+ * `count` (a number) wins. Otherwise `countField` is read off the record: a
+ * list counts its items, a number is taken as is.
+ *
+ * @param {{count?: number, countField?: string}|null} tab The tab declaration.
+ * @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
+ */
+export function resolveTabCount(tab, object) {
+	if (!tab || typeof tab !== 'object') {
+		return null
+	}
+	if (typeof tab.count === 'number' && Number.isFinite(tab.count)) {
+		return tab.count
+	}
+	if (typeof tab.countField !== 'string' || tab.countField === '') {
+		return null
+	}
+	const value = readPath(object && typeof object === 'object' ? object : {}, tab.countField)
+	if (Array.isArray(value)) {
+		return value.length
+	}
+	if (value === null || value === undefined || value === '') {
+		return 0
+	}
+	const number = Number(value)
+	return Number.isFinite(number) ? number : null
+}

package/src/utils/dueRule.js

@@ -0,0 +1,94 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * dueRule: decides whether a dated card is overdue, due soon or fine.
+ *
+ * A board's rule is `{ field, soonDays?, variantWhen? }`. `field` is a
+ * dot-path to the date on the row. `soonDays` (default 3) is how many days
+ * ahead still counts as "soon"; a date before today is overdue.
+ *
+ * The deciding is done by `utils/dateVariant.js`, the same rules a table's
+ * date cell uses, so a list and its board agree on what late means.
+ * `{ soonDays: 3 }` is shorthand for
+ * `variantWhen: [{ op: 'lt', value: 0, variant: 'error' }, { op: 'lte', value: 3, variant: 'warning' }]`,
+ * and a rule that carries its own `variantWhen` is used as written:
+ * `error` reads as overdue, `warning` as due soon.
+ *
+ * @module utils/dueRule
+ */
+
+import { daysUntil, parseDateValue, resolveDateVariant } from './dateVariant.js'
+import { readPath } from './readPath.js'
+
+export { daysUntil }
+
+/** How many days ahead counts as "soon" when the rule does not say. */
+export const DEFAULT_SOON_DAYS = 3
+
+/**
+ * Local midnight of a date value. A bare `YYYY-MM-DD` is a LOCAL day.
+ *
+ * @param {unknown} value A Date, a timestamp or a date string.
+ * @return {Date|null} Local midnight of that day, or null when unreadable.
+ * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-late-marking-on-board-cards
+ */
+export function toLocalDay(value) {
+	const date = parseDateValue(value)
+	return date === null ? null : new Date(date.getFullYear(), date.getMonth(), date.getDate())
+}
+
+/**
+ * The `variantWhen` rules a due rule stands for.
+ *
+ * @param {{soonDays?: number, variantWhen?: Array<object>}|null} [rule] The due rule.
+ * @return {Array<{op: string, value: number, variant: string}>} The rules `resolveDateVariant` takes.
+ * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-late-marking-on-board-cards
+ */
+export function dueRuleToVariantWhen(rule = {}) {
+	if (Array.isArray(rule?.variantWhen) && rule.variantWhen.length > 0) {
+		return rule.variantWhen
+	}
+	const given = rule?.soonDays
+	const soonDays = given !== null && given !== undefined && Number.isFinite(Number(given)) ? Number(given) : DEFAULT_SOON_DAYS
+	return [
+		{ op: 'lt', value: 0, variant: 'error' },
+		{ op: 'lte', value: soonDays, variant: 'warning' },
+	]
+}
+
+/**
+ * The due state of one date under a rule.
+ *
+ * @param {unknown} value The date.
+ * @param {{soonDays?: number, variantWhen?: Array<object>}|null} [rule] The rule.
+ * @param {Date} [now] The moment to measure from.
+ * @return {'overdue'|'soon'|'ok'|null} The state, or null when there is no readable date.
+ * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-late-marking-on-board-cards
+ */
+export function dueStateOf(value, rule = {}, now = new Date()) {
+	if (daysUntil(value, now) === null) {
+		return null
+	}
+	const variant = resolveDateVariant(value, dueRuleToVariantWhen(rule), now)
+	if (variant === 'error') {
+		return 'overdue'
+	}
+	return variant === 'warning' ? 'soon' : 'ok'
+}
+
+/**
+ * The due state of a row under a `{ field, soonDays }` rule.
+ *
+ * @param {object} row The row or card.
+ * @param {{field?: string, soonDays?: number, variantWhen?: Array<object>}|null} rule The rule. Null or field-less means no marking.
+ * @param {Date} [now] The moment to measure from.
+ * @return {'overdue'|'soon'|'ok'|null} The state, or null when the rule does not apply.
+ * @spec openspec/changes/detail-action-model-and-case-surfaces/specs/detail-action-model/spec.md#requirement-late-marking-on-board-cards
+ */
+export function dueStateForRow(row, rule, now = new Date()) {
+	if (!rule || typeof rule.field !== 'string' || rule.field === '' || !row) {
+		return null
+	}
+	return dueStateOf(readPath(row, rule.field), rule, now)
+}

package/src/utils/fetchAggregate.js

@@ -77,3 +77,39 @@ export async function fetchAggregateValue(source, ctx) {
 	const res = await axios.get(url, { params })
 	return (res && res.data && res.data.value !== undefined) ? res.data.value : null
 }
+
+/**
+ * Fetch the object count per distinct value of one field, in ONE request,
+ * from OpenRegister's `/grouped` aggregation endpoint.
+ *
+ * @param {object} source The grouped descriptor.
+ * @param {string} source.register The register slug.
+ * @param {string} source.schema The schema slug.
+ * @param {string} source.groupBy The field to group on.
+ * @param {object} [source.filter] The filter map.
+ * @param {{objectId?: (string|number), object?: object, workspace?: object}} [ctx] Optional
+ *   token-resolution context for the filter.
+ * @return {Promise<Array<{key: string, count: number}>>} One entry per group; [] when the source is incomplete.
+ * @spec openspec/changes/workplace-dashboard-primitives/specs/workplace-dashboard-primitives/spec.md#requirement-stacked-bar-widget
+ */
+export async function fetchGroupedCounts(source, ctx) {
+	const s = source || {}
+	if (!s.register || !s.schema || !s.groupBy) {
+		return []
+	}
+	const [{ default: axios }, { generateUrl }] = await Promise.all([
+		import('@nextcloud/axios'),
+		import('@nextcloud/router'),
+	])
+	const url = generateUrl(
+		'/apps/openregister/api/objects/aggregations/{register}/{schema}/grouped',
+		{ register: s.register, schema: s.schema },
+	)
+	const params = { groupBy: s.groupBy, metric: 'count' }
+	flattenAggFilter(params, s.filter || {}, ctx)
+	const res = await axios.get(url, { params })
+	const groups = (res && res.data && Array.isArray(res.data.groups)) ? res.data.groups : []
+	return groups
+		.filter((g) => g && g.key !== null && g.key !== undefined && g.key !== '')
+		.map((g) => ({ key: String(g.key), count: Number(g.value) || 0 }))
+}

package/src/utils/fetchFilterCounts.js

@@ -0,0 +1,182 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * fetchFilterCounts: how many records each of a set of filters matches, in as
+ * few requests as the API allows.
+ *
+ * Quick filters and saved views usually differ in ONE field (`status: open`,
+ * `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.
+ * Nothing is requested for an entry that did not ask.
+ *
+ * @module utils/fetchFilterCounts
+ */
+
+import { fetchAggregateValue, fetchGroupedCounts } from './fetchAggregate.js'
+import { buildHeaders, buildQueryString, prefixUrl } from './headers.js'
+import { resolveFilterTokens } from './resolveFilterTokens.js'
+
+/**
+ * Whether a filter holds a list of values (`{ status: ['open', 'hold'] }`).
+ *
+ * The aggregation endpoints have no spelling for "one of these values", so a
+ * filter like this is never sent to them. It is counted through the list
+ * endpoint instead, which is where the page's own request sends it.
+ *
+ * @param {object} filter A filter map.
+ * @return {boolean} True when any value is an array.
+ * @spec openspec/changes/workplace-dashboard-primitives/specs/workplace-dashboard-primitives/spec.md#requirement-counts-on-filters-and-views
+ */
+export function hasListValue(filter) {
+	if (!filter || typeof filter !== 'object') {
+		return false
+	}
+	return Object.values(filter).some((value) => Array.isArray(value))
+}
+
+/**
+ * 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
+ * sends it: a list of values as repeated `field[]=`, an operator as
+ * `field[op]=`.
+ *
+ * @param {string} register The register slug.
+ * @param {string} schema The schema slug.
+ * @param {object} filter The filter map.
+ * @param {object} [ctx] Token-resolution context for the filter.
+ * @return {Promise<number|null>} The total, or null when the response carries none.
+ * @spec openspec/changes/workplace-dashboard-primitives/specs/workplace-dashboard-primitives/spec.md#requirement-counts-on-filters-and-views
+ */
+export async function fetchListTotal(register, schema, filter, ctx) {
+	const resolved = resolveFilterTokens(filter || {}, ctx || {})
+	const params = {}
+	for (const [key, value] of Object.entries(resolved || {})) {
+		if (value && typeof value === 'object' && !Array.isArray(value)) {
+			for (const [op, operand] of Object.entries(value)) {
+				params[`${key}[${op}]`] = operand
+			}
+		} else {
+			params[key] = value
+		}
+	}
+	const qs = buildQueryString({ ...params, _limit: 1 })
+	const url = prefixUrl(`/apps/openregister/api/objects/${encodeURIComponent(register)}/${encodeURIComponent(schema)}${qs}`)
+	const response = await fetch(url, { headers: buildHeaders() })
+	if (!response.ok) {
+		throw new Error(`list returned ${response.status}`)
+	}
+	const data = await response.json()
+	return typeof data.total === 'number' ? data.total : null
+}
+
+/**
+ * The single field a filter narrows on with a plain equality, or null when the
+ * filter is anything else.
+ *
+ * @param {object} filter A filter map.
+ * @return {{field: string, value: string}|null} The field and the value it must equal.
+ * @spec openspec/changes/workplace-dashboard-primitives/specs/workplace-dashboard-primitives/spec.md#requirement-counts-on-filters-and-views
+ */
+export function singleEqualityOf(filter) {
+	if (!filter || typeof filter !== 'object' || Array.isArray(filter)) {
+		return null
+	}
+	const keys = Object.keys(filter)
+	if (keys.length !== 1) {
+		return null
+	}
+	const value = filter[keys[0]]
+	if (value === null || value === undefined || value === '' || typeof value === 'object') {
+		return null
+	}
+	// A token (`@me`, `@today`) resolves to a value the grouped keys are
+	// compared against only after resolution, which the count request does.
+	if (typeof value === 'string' && value.charAt(0) === '@') {
+		return null
+	}
+	return { field: keys[0], value: String(value) }
+}
+
+/**
+ * Count the records each entry's filter matches.
+ *
+ * @param {object} options The request.
+ * @param {string} options.register The register slug.
+ * @param {string} options.schema The schema slug.
+ * @param {Array<{key: (string|number), filter: object}>} options.entries The filters to count, each under its own key.
+ * @param {object} [options.baseFilter] A filter every count is narrowed by (the page's fixed filter).
+ * @param {object} [options.ctx] Token-resolution context for the filters.
+ * @return {Promise<{[key: string]: number}>} The count per entry key. An entry whose count failed is left out.
+ * @spec openspec/changes/workplace-dashboard-primitives/specs/workplace-dashboard-primitives/spec.md#requirement-counts-on-filters-and-views
+ */
+export async function fetchFilterCounts({ register, schema, entries, baseFilter, ctx } = {}) {
+	const counts = {}
+	if (!register || !schema || !Array.isArray(entries) || entries.length === 0) {
+		return counts
+	}
+	const base = (baseFilter && typeof baseFilter === 'object') ? baseFilter : {}
+
+	// Entries that share one equality field go into one grouped request, but
+	// only when at least two do: a lone entry costs one request either way,
+	// 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 byField = {}
+	const single = []
+	const viaList = []
+	for (const entry of entries) {
+		if (baseHasList || hasListValue(entry.filter)) {
+			viaList.push(entry)
+			continue
+		}
+		const eq = singleEqualityOf(entry.filter)
+		if (eq !== null && !(eq.field in base)) {
+			(byField[eq.field] = byField[eq.field] || []).push({ entry, value: eq.value })
+		} else {
+			single.push(entry)
+		}
+	}
+	const jobs = []
+	for (const [field, members] of Object.entries(byField)) {
+		if (members.length < 2) {
+			single.push(members[0].entry)
+			continue
+		}
+		jobs.push(fetchGroupedCounts({ register, schema, groupBy: field, filter: base }, ctx)
+			.then((groups) => {
+				const map = {}
+				for (const group of groups) {
+					map[group.key] = group.count
+				}
+				for (const member of members) {
+					counts[member.entry.key] = map[member.value] || 0
+				}
+			})
+			.catch(() => {}))
+	}
+	for (const entry of single) {
+		jobs.push(fetchAggregateValue({ register, schema, metric: 'count', filter: { ...base, ...(entry.filter || {}) } }, ctx)
+			.then((value) => {
+				if (value !== null && Number.isFinite(Number(value))) {
+					counts[entry.key] = Number(value)
+				}
+			})
+			.catch(() => {}))
+	}
+	for (const entry of viaList) {
+		jobs.push(fetchListTotal(register, schema, { ...base, ...(entry.filter || {}) }, ctx)
+			.then((total) => {
+				if (total !== null) {
+					counts[entry.key] = total
+				}
+			})
+			.catch(() => {}))
+	}
+	await Promise.all(jobs)
+	return counts
+}

package/src/utils/headers.js

@@ -130,10 +130,15 @@ export function capitalize(str) {
  *
  * Array values are serialized with PHP bracket notation (`key[]=a&key[]=b`)
  * so the Nextcloud/OpenRegister backend parses them as an array — a plain
- * repeated `key=a&key=b` collapses to the last value in PHP. Also handles
- * _order serialization (JSON.stringify for objects) and skips
+ * repeated `key=a&key=b` collapses to the last value in PHP. A plain object
+ * under a filter key is a set of operators and goes out in bracket form
+ * (`{ deadline: { lt: 'x' } }` becomes `deadline[lt]=x`); a key already
+ * written that way (`'deadline[lt]'`) passes through unchanged. Reserved keys
+ * that start with `_` keep their JSON form (`_order`). Skips
  * null/undefined/empty values.
  *
+ * @spec openspec/changes/link-cards-page/specs/link-cards-page/spec.md#requirement-a-filter-operator-is-serialised-in-bracket-form
+ *
  * @param {object} params Key-value pairs for query parameters
  * @return {string} Query string including leading '?' or empty string
  */
@@ -159,6 +164,27 @@ export function buildQueryString(params = {}) {
 					queryParams.append(arrayKey, String(item))
 				}
 			}
+		} else if (typeof value === 'object' && !key.startsWith('_')) {
+			// A filter operator: `{ deadline: { lt: '2026-10-06' } }` goes out
+			// as `deadline[lt]=2026-10-06`, the form OpenRegister reads. As
+			// JSON it reached the database as the literal value and a date
+			// column answered 500. Reserved `_` keys (`_order`) keep JSON.
+			for (const [op, operand] of Object.entries(value)) {
+				if (operand === undefined || operand === null || operand === '') {
+					continue
+				}
+				if (Array.isArray(operand)) {
+					for (const item of operand) {
+						if (item !== undefined && item !== null && item !== '') {
+							queryParams.append(`${key}[${op}][]`, String(item))
+						}
+					}
+				} else if (typeof operand === 'object') {
+					queryParams.set(`${key}[${op}]`, JSON.stringify(operand))
+				} else {
+					queryParams.set(`${key}[${op}]`, String(operand))
+				}
+			}
 		} else if (typeof value === 'object') {
 			queryParams.set(key, JSON.stringify(value))
 		} else {

package/src/utils/index.js

@@ -11,6 +11,7 @@ export { safeHref, safeImageSrc, safeSvgPath } from './safeHref.js'
 export { followLinkClick, isModifiedClick, openRowTarget, resolveHref } from './linkNavigation.js'
 export { isNewTabHandled, isRowMiddleClick } from './rowAuxClick.js'
 export { resolveImageUrl } from './resolveImageUrl.js'
+export { resolveDateVariant } from './dateVariant.js'
 export { compareVisibleWhen, evaluateVisibleWhen, evaluateVisibleWhenLocal, isLocallyDecidableVisibleWhen, readVisibleWhenPath } from './visibleWhen.js'
 export { validateFieldValue } from './formValidation.js'
 export { computeObjectDiff } from './computeObjectDiff.js'

package/src/utils/libraryWidgetKeys.js

@@ -93,10 +93,12 @@ export const DASHBOARD_CATALOG_WIDGET_KEYS = Object.freeze([
 	'calendar',
 	'chart',
 	'container',
+	'conversation',
 	'countdown',
 	'data',
 	'delta',
 	'divider',
+	'document-review',
 	'files',
 	'flow-runs',
 	'gauge',
@@ -110,6 +112,7 @@ export const DASHBOARD_CATALOG_WIDGET_KEYS = Object.freeze([
 	'map',
 	'menu',
 	'nc-widget',
+	'next-step',
 	// `news` was here until the widget moved to LaunchPad, which owns the feed
 	// fetching. An app that renders one now gets it from LaunchPad's registry.
 	'object-geo',
@@ -119,6 +122,7 @@ export const DASHBOARD_CATALOG_WIDGET_KEYS = Object.freeze([
 	'quicklinks',
 	'related',
 	'spend-analytics',
+	'stacked-bar',
 	'stages',
 	'stat',
 	'stats-block',
@@ -128,6 +132,7 @@ export const DASHBOARD_CATALOG_WIDGET_KEYS = Object.freeze([
 	'text',
 	'tile',
 	'video',
+	'week-strip',
 	'workspace-filter',
 ])