@conduction/nextcloud-vue 2.62.0 → 2.63.0

package/src/css/dashboard.css

@@ -80,3 +80,52 @@
 .cn-dashboard-list__item:hover {
 	background: var(--color-background-hover);
 }
+
+/* "Install <app>" placeholder in a widget whose app is missing.
+ *
+ * NcEmptyContent centres its content with `justify-content: center`. In a
+ * two-row dashboard tile (about 150px inside an `overflow: hidden` wrapper)
+ * the icon, name, description and button are taller than the tile, and plain
+ * `center` overflows on BOTH sides, so the top ran out of the widget and the
+ * name was cut off. `safe center` falls back to the start edge when the
+ * content does not fit, the spacing is compact, and what still does not fit
+ * scrolls instead of being clipped. Shared by CnDashboardPage and
+ * CnDetailWidgetHost (`cn-requires-app`). The class is doubled to outrank
+ * NcEmptyContent's own scoped rules (`.empty-content[data-v-…]`) whatever
+ * order the stylesheets load in. */
+.cn-requires-app.cn-requires-app.empty-content,
+.cn-requires-app.cn-requires-app .empty-content {
+	justify-content: safe center;
+	min-height: 0;
+	max-height: 100%;
+	overflow: auto;
+	margin: 0;
+	padding: calc(2 * var(--default-grid-baseline, 4px));
+	gap: var(--default-grid-baseline, 4px);
+	box-sizing: border-box;
+}
+
+.cn-requires-app.cn-requires-app .empty-content__icon {
+	width: auto;
+	height: auto;
+	min-height: 0;
+	margin: 0;
+	opacity: 0.7;
+}
+
+.cn-requires-app.cn-requires-app .empty-content__name {
+	margin: 0;
+	font-size: var(--default-font-size, 15px);
+	font-weight: 600;
+	text-align: center;
+}
+
+.cn-requires-app.cn-requires-app .empty-content__description {
+	margin: 0;
+	text-align: center;
+	font-size: 0.9em;
+}
+
+.cn-requires-app.cn-requires-app .empty-content__action {
+	margin-top: var(--default-grid-baseline, 4px);
+}

package/src/css/detail-page.css

@@ -106,6 +106,25 @@
 	flex-shrink: 0;
 }
 
+/* Every control in the header sits on one line at one height. The lifecycle
+   bar carries `margin: 0 0 8px` for its place above a page body; in the
+   header that margin pushed its buttons up and made the row 8px taller, so
+   the Edit button beside it read as the bigger one. A consumer's actions
+   component can bring its own margins too, so they are reset here as well. */
+.cn-detail-page .cn-detail-page__header-actions .cn-lifecycle-actions {
+	margin: 0;
+	flex-wrap: nowrap;
+}
+
+.cn-detail-page .cn-detail-page__header-actions > * {
+	margin-block: 0;
+}
+
+.cn-detail-page .cn-detail-page__header-actions .button-vue {
+	min-height: var(--default-clickable-area);
+	block-size: var(--default-clickable-area);
+}
+
 /* The sentence a refused lock acquire left behind, under the locked banner. */
 .cn-detail-page__lock-refusal {
 	margin: 0 0 calc(3 * var(--default-grid-baseline));

package/src/css/table.css

@@ -295,6 +295,87 @@
 	outline-offset: -2px;
 }
 
+/* Header filter button (CnDataTable `filterable`). 24px hit area with the
+   16px icon; the filled icon plus the primary colour marks an active filter,
+   so the state never rests on colour alone. */
+.cn-table-header__filter {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	width: 24px;
+	min-width: 24px;
+	height: 24px;
+	min-height: 24px;
+	margin: 0 0 0 4px;
+	padding: 0;
+	border: none;
+	border-radius: var(--border-radius, 4px);
+	background: transparent;
+	color: var(--color-text-maxcontrast);
+	vertical-align: middle;
+	cursor: pointer;
+}
+
+.cn-table-header__filter:hover {
+	background-color: var(--color-background-hover);
+	color: var(--color-main-text);
+}
+
+.cn-table-header__filter:focus-visible {
+	outline: 2px solid var(--color-main-text);
+	outline-offset: 0;
+}
+
+.cn-table-header__filter--active {
+	color: var(--color-primary-element);
+}
+
+/* Active header filters above the table, one removable chip each. */
+.cn-data-table__filter-chips {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 6px;
+	margin: 0 0 8px;
+	padding: 0;
+	list-style: none;
+}
+
+.cn-data-table__filter-chip {
+	display: inline-flex;
+	align-items: center;
+	gap: 4px;
+	padding: 2px 4px 2px 10px;
+	border: 1px solid var(--color-border-dark);
+	border-radius: var(--border-radius-pill, 16px);
+	background-color: var(--color-background-dark);
+	color: var(--color-main-text);
+}
+
+.cn-data-table__filter-chip-remove {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	width: 24px;
+	min-width: 24px;
+	height: 24px;
+	min-height: 24px;
+	margin: 0;
+	padding: 0;
+	border: none;
+	border-radius: 50%;
+	background: transparent;
+	color: var(--color-main-text);
+	cursor: pointer;
+}
+
+.cn-data-table__filter-chip-remove:hover {
+	background-color: var(--color-background-hover);
+}
+
+.cn-data-table__filter-chip-remove:focus-visible {
+	outline: 2px solid var(--color-main-text);
+}
+
 /* Multi-column sort priority badge (1, 2, 3), rendered only when two or more rendered, sortable columns are sorted. */
 .cn-table-sort-badge {
 	display: inline-flex;

package/src/index.js

@@ -35,6 +35,7 @@ export {
 	CnActionsBar,
 	CnActionsMenu,
 	CnAddWidgetModal,
+	CnAdminActionCard,
 	CnAdminSettingsShell,
 	CnAdvancedFormDialog,
 	CnAppLoading,
@@ -268,6 +269,7 @@ export {
 	CnTileWidget,
 	CnTimelineStages,
 	CnTimelineView,
+	CnTimelineWidget,
 	CnTranslatedBadge,
 	CnTreeView,
 	CnUserActionMenu,

package/src/schemas/app-manifest-v2.schema.json

@@ -3,7 +3,7 @@
 	"$id": "https://raw.githubusercontent.com/ConductionNL/nextcloud-vue/main/src/schemas/app-manifest-v2.schema.json",
 	"title": "Conduction App Manifest v2",
 	"description": "v2 schema for the JSON-driven page and navigation manifest consumed by @conduction/nextcloud-vue. Introduces a uniform widgets[] array on every page type with a per-slot grid coordinate system, a typed actions[] discriminator, and the required $schema field for version detection. v1 manifests continue to validate against app-manifest.schema.json (unchanged).",
-	"version": "2.43.0",
+	"version": "2.45.0",
 	"type": "object",
 	"required": ["$schema", "version"],
 	"allOf": [
@@ -97,6 +97,8 @@
 							"suggestFrom": { "type": "string", "description": "choice: the configKey of an earlier choice this step pre-fills a suggestion from. When that value is set and the user has not yet picked here, the option matching suggestMap[parentValue] is auto-selected (still user-overridable)." },
 							"suggestMap": { "type": "object", "description": "choice: map of suggestFrom value → suggested option value. Used to auto-suggest a default (e.g. RGS template suggested from organisation type).", "additionalProperties": { "type": "string" } },
 							"multiple": { "type": "boolean", "default": false, "description": "choice: allow multi-select." },
+							"loadAction": { "type": "string", "minLength": 1, "description": "choice with display cards: an actionId each option card loads itself with. Every card except the one whose value is `none` gets its own Load button, which POSTs { dataset: <value> } to /api/setup/action/{loadAction}, spins while it runs and shows the result on that card. A successful load also selects the card. With loadAction the separate run-action step that loaded the picked dataset is no longer needed; manifests that keep it still work." },
+							"requires": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true, "description": "App ids this step needs. When any of them is not installed and enabled, the wizard skips the step and the summary shows it as skipped, naming the missing apps. Do not combine with required: true; setup status would keep reporting the skipped step as unmet." },
 							"action": { "type": "string", "description": "run-action: actionId POSTed to /api/setup/action/{action}." },
 							"onDemand": { "type": "boolean", "default": false, "description": "run-action: the step runs only when the user clicks Run, never automatically, and is never outstanding work (it does not open the wizard or decide where a resumed wizard starts). The summary ticks it only when its action succeeded in the current session and shows it as not run otherwise, whatever the server reports. For destructive steps an app reports as done on purpose so they never auto-run, such as removing example data." },
 							"healthCheck": { "type": "boolean", "default": false, "description": "summary: render a health recap." },
@@ -1173,6 +1175,11 @@
 					"type": "string",
 					"description": "i18n translation key resolved by the consuming app's t() function at render time."
 				},
+				"translateLabel": {
+					"type": "boolean",
+					"default": true,
+					"description": "Whether CnAppNav runs `label` through the translate function. Set false for a user-authored title (e.g. a catalog name) that must render as written even when it equals a translation key such as 'Search'. Rendered as text either way, never as HTML."
+				},
 				"icon": {
 					"type": "string",
 					"description": "CSS class for the icon (e.g. 'icon-checkmark') or MDI component name."
@@ -1186,6 +1193,11 @@
 					"additionalProperties": { "type": ["string", "number", "boolean"] },
 					"description": "Optional vue-router query parameters merged into the target route link (e.g. a filter like { caseType: '<uuid>' }). Deep-links a nav entry to a pre-filtered index page."
 				},
+				"params": {
+					"type": "object",
+					"additionalProperties": { "type": ["string", "number"], "minLength": 1 },
+					"description": "Optional vue-router route params for a parameterised route (e.g. { catalogSlug: 'news' } for a page at '/catalogs/:catalogSlug'). String values must be non-empty. CnAppNav links to { name: route, params, query }. The entry is active only while every declared param equals the current route's param (compared as strings), so sibling entries on one route that differ in params are never marked together. On pages whose path sits below its page path with these params filled in, it is active too: by the same params check when those routes carry the same param names, otherwise as the one entry marked below its route."
+				},
 				"order": {
 					"type": "integer",
 					"description": "Display order in the menu. Items without an order render last."
@@ -1259,6 +1271,11 @@
 			"properties": {
 				"id": { "type": "string" },
 				"label": { "type": "string" },
+				"translateLabel": {
+					"type": "boolean",
+					"default": true,
+					"description": "Same as menuItem.translateLabel: false renders `label` as written instead of translating it."
+				},
 				"icon": { "type": "string" },
 				"route": { "type": "string" },
 				"query": {
@@ -1266,6 +1283,11 @@
 					"additionalProperties": { "type": ["string", "number", "boolean"] },
 					"description": "Optional vue-router query parameters merged into the target route link (e.g. a filter like { caseType: '<uuid>' }). Deep-links a nav entry to a pre-filtered index page."
 				},
+				"params": {
+					"type": "object",
+					"additionalProperties": { "type": ["string", "number"], "minLength": 1 },
+					"description": "Optional vue-router route params for a parameterised route; string values must be non-empty. Same contract as menuItem.params: part of the link, and the entry is active only while every declared param equals the current route's param."
+				},
 				"order": { "type": "integer" },
 				"permission": { "type": "string" },
 				"section": {

package/src/store/useObjectStore.js

@@ -5,6 +5,7 @@ import { genericError, networkError, parseResponseError } from '../utils/errors.
 import { normalizeFacets } from '../utils/facets.js'
 import { buildHeaders, buildQueryString, capitalize, prefixUrl } from '../utils/headers.js'
 import { extractId } from '../utils/id.js'
+import { dispatchObjectCreated } from '../utils/walkthroughSignals.js'
 import { mergePluginActions, mergePluginGetters, mergePluginState } from './pluginMerge.js'
 import { liveUpdatesPlugin } from './plugins/liveUpdates.js'
 
@@ -830,6 +831,13 @@ const baseActions = {
 				[type]: { ...(this.objects[type] || {}), [savedId]: data },
 			}
 
+			// Every create through the store lets an `advanceOn:
+			// object-created` walkthrough step advance, whichever form made it.
+			if (!isUpdate) {
+				const config = this.objectTypeRegistry[type] || {}
+				dispatchObjectCreated({ register: config.registerSlug || config.register, schema: config.schemaSlug || config.schema, object: data })
+			}
+
 			return data
 		} catch (error) {
 			this.errors = {

package/src/utils/columnFilters.js

@@ -0,0 +1,324 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ */
+
+/**
+ * Per-column sorting and filtering for table headers.
+ *
+ * Pure helpers: which column can sort, which can filter and how, and the
+ * translation between a header filter's state and the OpenRegister query
+ * parameters the facet sidebar already sends. A header filter writes into the
+ * SAME active-filter map (`{ paramKey: values[] }`) the sidebar uses, so the
+ * fetch, the route query and saved views need nothing new.
+ *
+ * Parameter shapes, as OpenRegister reads them:
+ * - equality and "any of": `key=value`, `key[]=a&key[]=b`
+ * - ranges: `key[gte]=from`, `key[lte]=to`
+ *
+ * @module utils/columnFilters
+ * @spec openspec/changes/table-header-sort-and-filter/specs/cn-data-table/spec.md
+ */
+
+import { schemaRefSlug } from './schemaRefSlug.js'
+
+/** Column keys that mark a value computed on the client, never stored. */
+const COMPUTED_MARKERS = ['aggregate', 'compute', 'computed', 'virtual']
+
+/**
+ * Normalise a `$ref` to the referenced schema slug, or null.
+ *
+ * @param {unknown} ref A `$ref` value.
+ * @return {string|number|null} The slug.
+ */
+function refSlug(ref) {
+	if (typeof ref === 'number' && !Number.isNaN(ref)) {
+		return ref
+	}
+	if (typeof ref !== 'string' || ref === '') {
+		return null
+	}
+	const tail = ref.includes('/') ? ref.substring(ref.lastIndexOf('/') + 1) : ref
+	const slug = tail === '' ? '' : schemaRefSlug(tail)
+	return slug !== '' ? slug : null
+}
+
+/**
+ * The schema property behind a column, or null when the column has none.
+ *
+ * @param {object} column The column definition.
+ * @param {object|null} schema The table's schema.
+ * @return {object|null} The property.
+ */
+export function columnProperty(column, schema) {
+	if (!column || !schema || !schema.properties || typeof column.key !== 'string') {
+		return null
+	}
+	const prop = schema.properties[column.key]
+	return (prop && typeof prop === 'object') ? prop : null
+}
+
+/**
+ * Whether a column computes its value on the client, so the server cannot
+ * sort or filter on it.
+ *
+ * @param {object} column The column definition.
+ * @return {boolean} True for a computed column.
+ */
+function isComputedColumn(column) {
+	return COMPUTED_MARKERS.some((marker) => column[marker] !== undefined && column[marker] !== null && column[marker] !== false)
+}
+
+/**
+ * Whether a column header sorts.
+ *
+ * `sortable: false` always wins, and so does an explicit `sortable: true`.
+ * Otherwise, with a schema, a column sorts when a stored schema property backs
+ * it: OpenRegister orders on schema properties, so a widget or computed column
+ * with no property behind it stays unsortable. Without a schema nothing says
+ * the server can sort, so only an explicit flag makes the column sortable,
+ * which is how such tables behaved before.
+ *
+ * @param {object} column The column definition.
+ * @param {object|null} schema The table's schema.
+ * @return {boolean} True when the header sorts.
+ * @spec openspec/changes/table-header-sort-and-filter/specs/cn-data-table/spec.md#requirement-every-backed-column-sorts-by-default
+ */
+export function isColumnSortable(column, schema) {
+	if (!column || typeof column !== 'object') {
+		return false
+	}
+	if (column.sortable === false) {
+		return false
+	}
+	if (column.sortable === true) {
+		return true
+	}
+	if (!schema || isComputedColumn(column)) {
+		return false
+	}
+	const prop = columnProperty(column, schema)
+	return !!prop && prop.type !== 'object'
+}
+
+/**
+ * Display options for an enum filter: schema `enum` (or `items.enum`) with
+ * `x-enum-labels`, else a column `enum` hint, else a badge column's colour
+ * map keys.
+ *
+ * @param {object} column The column definition.
+ * @param {object|null} prop The schema property.
+ * @return {Array<{value: string, label: string}>} The options, or [].
+ */
+function enumOptions(column, prop) {
+	const p = prop || {}
+	const labels = p.enumLabels || p['x-enum-labels'] || (p.items && (p.items.enumLabels || p.items['x-enum-labels'])) || {}
+	let values = null
+	if (Array.isArray(p.enum) && p.enum.length > 0) {
+		values = p.enum
+	} else if (p.items && Array.isArray(p.items.enum) && p.items.enum.length > 0) {
+		values = p.items.enum
+	} else if (Array.isArray(column.enum) && column.enum.length > 0) {
+		values = column.enum
+	} else if (column.widget === 'badge' && column.widgetProps && column.widgetProps.colorMap) {
+		values = Object.keys(column.widgetProps.colorMap)
+	}
+	if (!values) {
+		return []
+	}
+	return values
+		.filter((v) => v !== null && v !== undefined && v !== '')
+		.map((v) => ({ value: String(v), label: String(labels[v] !== undefined ? labels[v] : v) }))
+}
+
+/**
+ * The reference a column points at, for a searchable object filter: a schema
+ * `$ref` (or `items.$ref`), else an `fkResolve` cell widget's config.
+ *
+ * @param {object} column The column definition.
+ * @param {object|null} prop The schema property.
+ * @return {{schema: (string|number), register: string, labelField: string}|null} The reference.
+ */
+function referenceTarget(column, prop) {
+	const widgetProps = (column.widget === 'fkResolve' && column.widgetProps) || null
+	const p = prop || {}
+	const schemaRef = refSlug(p.$ref) ?? (p.items ? refSlug(p.items.$ref) : null)
+	const schema = schemaRef ?? (widgetProps && widgetProps.schema ? widgetProps.schema : null)
+	if (schema === null || schema === undefined || schema === '') {
+		return null
+	}
+	const register = (widgetProps && widgetProps.register)
+		|| p['x-external-register']
+		|| (p.items && p.items['x-external-register'])
+		|| ''
+	const labelField = (widgetProps && widgetProps.labelField) || ''
+	return { schema, register, labelField }
+}
+
+/**
+ * How a column filters, or null when it does not.
+ *
+ * Kinds: `enum` (checkbox list), `boolean` (yes, no, any), `reference`
+ * (searchable list of the referenced objects), `number` and `date` (from and
+ * to), and `string` (equals). `filterable: false` on the column turns it
+ * off. A column with no schema property behind it only filters when it
+ * carries an enum hint (`enum`, or a badge widget's colour map), because the
+ * server cannot filter on a value it does not store.
+ *
+ * @param {object} column The column definition.
+ * @param {object|null} schema The table's schema.
+ * @return {{key: string, kind: string, label: string, options: Array<{value: string, label: string}>, reference: object|null, dateTime: boolean}|null} The filter definition.
+ * @spec openspec/changes/table-header-sort-and-filter/specs/cn-data-table/spec.md#requirement-every-backed-column-filters-from-its-header
+ */
+export function columnFilterDef(column, schema) {
+	if (!column || typeof column !== 'object' || typeof column.key !== 'string' || column.key === '') {
+		return null
+	}
+	if (column.filterable === false || isComputedColumn(column)) {
+		return null
+	}
+	const prop = columnProperty(column, schema)
+	const base = { key: column.key, label: column.label || (prop && prop.title) || column.key, options: [], reference: null, dateTime: false }
+
+	const options = enumOptions(column, prop)
+	if (options.length > 0) {
+		return { ...base, kind: 'enum', options }
+	}
+	if (!prop) {
+		return null
+	}
+	const reference = referenceTarget(column, prop)
+	if (reference) {
+		return { ...base, kind: 'reference', reference }
+	}
+	const type = Array.isArray(prop.type) ? prop.type.find((t) => t !== 'null') : prop.type
+	const format = prop.format || ''
+	if (type === 'boolean') {
+		return { ...base, kind: 'boolean' }
+	}
+	if (type === 'number' || type === 'integer') {
+		return { ...base, kind: 'number' }
+	}
+	if (type === 'string' && (format === 'date' || format === 'date-time')) {
+		return { ...base, kind: 'date', dateTime: format === 'date-time' }
+	}
+	if (type === 'string') {
+		return { ...base, kind: 'string' }
+	}
+	return null
+}
+
+/**
+ * Read one active-filter entry as a list of strings.
+ *
+ * @param {unknown} raw An active-filter value: an array, a scalar, or absent.
+ * @return {Array<string>} The values.
+ */
+function asList(raw) {
+	if (raw === undefined || raw === null || raw === '') {
+		return []
+	}
+	return (Array.isArray(raw) ? raw : [raw]).filter((v) => v !== undefined && v !== null && v !== '').map((v) => String(v))
+}
+
+/**
+ * The parameter keys one column filter owns.
+ *
+ * @param {object} def A filter definition from `columnFilterDef`.
+ * @return {Array<string>} The keys.
+ */
+export function columnFilterParamKeys(def) {
+	if (!def) {
+		return []
+	}
+	if (def.kind === 'number' || def.kind === 'date') {
+		return [`${def.key}[gte]`, `${def.key}[lte]`]
+	}
+	return [def.key]
+}
+
+/**
+ * A column filter's current state, read from the active-filter map.
+ *
+ * @param {object} def A filter definition.
+ * @param {object} activeFilters The active-filter map (`{ paramKey: values }`).
+ * @return {object} `{ values }` for enum and reference, `{ value }` for boolean and string, `{ from, to }` for number and date.
+ */
+export function columnFilterState(def, activeFilters) {
+	const filters = (activeFilters && typeof activeFilters === 'object') ? activeFilters : {}
+	if (!def) {
+		return {}
+	}
+	if (def.kind === 'enum' || def.kind === 'reference') {
+		return { values: asList(filters[def.key]) }
+	}
+	if (def.kind === 'number' || def.kind === 'date') {
+		const from = asList(filters[`${def.key}[gte]`])[0] || ''
+		const to = asList(filters[`${def.key}[lte]`])[0] || ''
+		// A date-time column is queried up to the end of the day; the input
+		// shows the date the person picked.
+		return {
+			from: def.kind === 'date' ? from.slice(0, 10) : from,
+			to: def.kind === 'date' ? to.slice(0, 10) : to,
+		}
+	}
+	return { value: asList(filters[def.key])[0] || '' }
+}
+
+/**
+ * Whether a column filter is active.
+ *
+ * @param {object} def A filter definition.
+ * @param {object} activeFilters The active-filter map.
+ * @return {boolean} True when any of its parameters is set.
+ */
+export function isColumnFilterActive(def, activeFilters) {
+	const filters = (activeFilters && typeof activeFilters === 'object') ? activeFilters : {}
+	return columnFilterParamKeys(def).some((key) => asList(filters[key]).length > 0)
+}
+
+/**
+ * The active-filter entries a column filter state produces. Every key the
+ * column owns is present; an empty list clears that key, so changing a range
+ * from "from and to" to "from" drops the old upper bound.
+ *
+ * @param {object} def A filter definition.
+ * @param {object} state The column filter state (see `columnFilterState`).
+ * @return {object} `{ paramKey: values[] }`.
+ * @spec openspec/changes/table-header-sort-and-filter/specs/cn-data-table/spec.md#requirement-a-header-filter-speaks-the-sidebars-query-language
+ */
+export function columnFilterParams(def, state) {
+	const s = state || {}
+	if (!def) {
+		return {}
+	}
+	if (def.kind === 'enum' || def.kind === 'reference') {
+		return { [def.key]: asList(s.values) }
+	}
+	if (def.kind === 'number' || def.kind === 'date') {
+		const from = s.from === undefined || s.from === null ? '' : String(s.from).trim()
+		let to = s.to === undefined || s.to === null ? '' : String(s.to).trim()
+		if (def.kind === 'date' && def.dateTime && to !== '' && to.length === 10) {
+			to = `${to}T23:59:59`
+		}
+		return {
+			[`${def.key}[gte]`]: from === '' ? [] : [from],
+			[`${def.key}[lte]`]: to === '' ? [] : [to],
+		}
+	}
+	if (def.kind === 'boolean') {
+		return { [def.key]: (s.value === 'true' || s.value === 'false') ? [s.value] : [] }
+	}
+	const value = s.value === undefined || s.value === null ? '' : String(s.value).trim()
+	return { [def.key]: value === '' ? [] : [value] }
+}
+
+/**
+ * Clear-all entries for one column: every key it owns, emptied.
+ *
+ * @param {object} def A filter definition.
+ * @return {object} `{ paramKey: [] }`.
+ */
+export function clearedColumnFilterParams(def) {
+	return Object.fromEntries(columnFilterParamKeys(def).map((key) => [key, []]))
+}