@conduction/nextcloud-vue 2.106.0 → 2.107.0

package/src/mixins/savedViewsList.js

@@ -0,0 +1,231 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * savedViewsList — what the saved-views panel and the toolbar chips share:
+ * the views as a tree with the defaults first, the sections, the labels,
+ * counts and access. Presentational only; the page owns fetching and writes.
+ *
+ * @spec openspec/changes/saved-views-manage-and-defaults/tasks.md#task-6
+ */
+import { translate as t } from '@nextcloud/l10n'
+import { buildViewTree, labelsInUse, VIEW_GROUPS } from '../utils/buildViewTree.js'
+import { viewAccess } from '../utils/savedViewHelpers.js'
+
+export const savedViewsList = {
+	props: {
+		/** Views to list (View API objects from `GET /apps/openregister/api/views`, defaults included). */
+		views: {
+			type: Array,
+			default: () => [],
+		},
+
+		/** True while the parent is fetching the view list. */
+		loading: {
+			type: Boolean,
+			default: false,
+		},
+
+		/** The signed-in NC user id; a view without `@self.access` is the owner's when it matches. */
+		currentUserId: {
+			type: String,
+			default: '',
+		},
+
+		/** How deep the tree indents before it flattens (`savedViewTree.maxDepth`). */
+		maxDepth: {
+			type: Number,
+			default: 3,
+		},
+
+		/**
+		 * How many records each view matches, keyed by view id (or slug). `null`
+		 * shows no counts.
+		 *
+		 * @type {{[viewId: string]: number}|null}
+		 */
+		counts: {
+			type: Object,
+			default: null,
+		},
+
+		/** The id (or slug) of the applied view. */
+		selectedViewId: {
+			type: String,
+			default: '',
+		},
+	},
+
+	data() {
+		return {
+			/** The label currently filtering the list, or '' for all of them. */
+			labelFilter: '',
+		}
+	},
+
+	computed: {
+		/** @return {string} The seeded group name, for templates. */
+		SEEDED_GROUP() {
+			return VIEW_GROUPS.SEEDED
+		},
+
+		/**
+		 * The views in tree order, defaults first, filtered by the active label.
+		 *
+		 * @return {Array<object>} Rows of `{ view, depth, group, orphaned }`.
+		 */
+		rows() {
+			return buildViewTree({ views: this.views, labelFilter: this.labelFilter, maxDepth: this.maxDepth })
+		},
+
+		/**
+		 * The rows in their sections: one uncaptioned section when nothing is
+		 * shared and nothing is a default, else Default views, My views and
+		 * Shared with me.
+		 *
+		 * @return {Array<{key: string, label: string, rows: Array<object>}>} The sections.
+		 * @spec openspec/changes/saved-views-shared-by-role/tasks.md#task-1
+		 */
+		sections() {
+			const shared = this.rows.filter((r) => r.group !== VIEW_GROUPS.SEEDED && this.accessOf(r) !== 'owner')
+			const seeded = this.rows.filter((r) => r.group === VIEW_GROUPS.SEEDED)
+			if (shared.length === 0 && seeded.length === 0) {
+				return [{ key: 'all', label: '', rows: this.rows }]
+			}
+			const mine = this.rows.filter((r) => r.group !== VIEW_GROUPS.SEEDED && this.accessOf(r) === 'owner')
+			return [
+				{ key: 'seeded', label: t('nextcloud-vue', 'Default views'), rows: seeded },
+				{ key: 'mine', label: t('nextcloud-vue', 'My views'), rows: mine },
+				{ key: 'shared', label: t('nextcloud-vue', 'Shared with me'), rows: shared },
+			].filter((section) => section.rows.length > 0)
+		},
+
+		/**
+		 * The labels in use, read from the UNFILTERED list so choosing one keeps
+		 * the others on offer.
+		 *
+		 * @return {Array<string>} The labels.
+		 */
+		offeredLabels() {
+			return labelsInUse(this.views)
+		},
+	},
+
+	methods: {
+		t,
+
+		/**
+		 * Whether a view is the applied one.
+		 *
+		 * @param {object} view The view.
+		 * @return {boolean}
+		 */
+		isSelected(view) {
+			return this.selectedViewId !== '' && (this.selectedViewId === String(view.id) || this.selectedViewId === String(view.slug))
+		},
+
+		/**
+		 * What the current user may do with a row's view.
+		 *
+		 * @param {object} row The row from buildViewTree().
+		 * @return {'owner'|'write'|'read'} The access.
+		 */
+		accessOf(row) {
+			return viewAccess(row.view, this.currentUserId)
+		},
+
+		/**
+		 * The people and groups a view is shared with, as text.
+		 *
+		 * @param {object} view The View API object.
+		 * @return {string} The user and group ids, comma-separated; empty when none.
+		 */
+		groupsOf(view) {
+			return (Array.isArray(view.sharedWith) ? view.sharedWith : [])
+				.map((e) => e && (e.user || e.group))
+				.filter((g) => typeof g === 'string' && g !== '')
+				.join(', ')
+		},
+
+		/**
+		 * The name a row shows, indented to its depth with figure spaces so a
+		 * screen reader gets the same shape.
+		 *
+		 * @param {object} row The row from buildViewTree().
+		 * @param {boolean} [withGroups] Append who the view is shared with.
+		 * @return {string} The name.
+		 */
+		rowName(row, withGroups = false) {
+			const groups = withGroups ? this.groupsOf(row.view) : ''
+			return `${' '.repeat(row.depth * 2)}${this.nameWithCount(row.view)}${groups !== '' ? ` · ${groups}` : ''}`
+		},
+
+		/**
+		 * The number of records a view matches, or null when none is known.
+		 *
+		 * @param {object} view The saved view.
+		 * @return {number|null}
+		 */
+		countOf(view) {
+			const counts = this.counts || {}
+			let value = counts[view.id]
+			if (value === undefined || value === null) {
+				value = counts[view.slug]
+			}
+			if (value === undefined || value === null) {
+				value = view.count
+			}
+			return (typeof value === 'number' && Number.isFinite(value)) ? value : null
+		},
+
+		/**
+		 * A view's name, followed by its count when one is known.
+		 *
+		 * @param {object} view The saved view.
+		 * @return {string}
+		 */
+		nameWithCount(view) {
+			const count = this.countOf(view)
+			return count === null ? view.name : `${view.name} (${count})`
+		},
+
+		/**
+		 * What a row is called to somebody who cannot see the indentation: the
+		 * level in words, and a note when its parent is out of reach.
+		 *
+		 * @param {object} row The row from buildViewTree().
+		 * @return {string} The accessible label.
+		 */
+		rowLabel(row) {
+			const viewName = this.nameWithCount(row.view)
+			const name = row.depth === 0
+				? viewName
+				: t('nextcloud-vue', '{name}, level {level}', { name: viewName, level: row.depth + 1 })
+			if (row.orphaned !== true) {
+				return name
+			}
+			return t('nextcloud-vue', '{name}. Parts of this view come from one you cannot see.', { name })
+		},
+
+		/**
+		 * The accessible label of a label filter entry.
+		 *
+		 * @param {string} label The label.
+		 * @return {string}
+		 */
+		labelFilterLabel(label) {
+			return this.labelFilter === label
+				? t('nextcloud-vue', 'Stop filtering on "{label}"', { label })
+				: t('nextcloud-vue', 'Show only views labelled "{label}"', { label })
+		},
+
+		/**
+		 * Turn a label filter on, or off when it is already on.
+		 *
+		 * @param {string} label The label.
+		 */
+		onLabelFilter(label) {
+			this.labelFilter = this.labelFilter === label ? '' : label
+		},
+	},
+}

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.129.0",
+	"version": "2.131.0",
 	"type": "object",
 	"required": ["$schema", "version"],
 	"allOf": [
@@ -1060,7 +1060,8 @@
 				},
 				"seeded": {
 					"type": "array",
-					"description": "Views that ship with the app. They render as their own group above the user's own, and a user may copy one but not delete it: a view the product promises is not a view one person can remove from everybody's install.",
+					"deprecated": true,
+					"description": "DEPRECATED since 2.129.0: declare default views with the index page's `config.defaultSavedViews`, which carries the criteria this key never had and is what the page actually lists. Nothing ever read this key, so moving off it loses nothing. Views that ship with the app. They render as their own group above the user's own, and a user may copy one but not delete it: a view the product promises is not a view one person can remove from everybody's install.",
 					"items": {
 						"type": "object",
 						"additionalProperties": false,
@@ -4477,6 +4478,52 @@
 							"type": "string",
 							"description": "type='index': which pages share this page's saved views. By default a view is shared by every page over the same register and schema and by no other, because a view is filters over one schema's fields. Set this to share views across pages over different sources, or to keep two pages over one source apart. Written into the saved view's `query.scope`; views saved before scoping stay visible everywhere. Maps to CnIndexPage `savedViewsScope`."
 						},
+						"defaultSavedViews": {
+							"type": "array",
+							"description": "type='index': views the app ships for this page. Listed read-only above each user's own saved views, under Default views, and never stored: a new app version updates them for everybody and no user can delete one. A user may apply a default or save a copy, which they then own. `@`-tokens in `filters` (`@me`, `@today`, `@today+7d`) resolve when the default is applied; a copy keeps them. Maps to CnIndexPage `defaultSavedViews`.",
+							"items": {
+								"type": "object",
+								"additionalProperties": false,
+								"required": ["slug", "name", "filters"],
+								"properties": {
+									"slug": {
+										"type": "string",
+										"pattern": "^[a-z0-9][a-z0-9-]*$",
+										"description": "The stable name of the default. Lowercase and dash only."
+									},
+									"name": {
+										"type": "string",
+										"minLength": 1,
+										"description": "What the filter is called in the control. Translatable."
+									},
+									"filters": {
+										"type": "object",
+										"description": "The filters, keyed by property, in the shape a quick filter's `filter` takes."
+									},
+									"search": {
+										"type": "string",
+										"description": "A search term the default applies."
+									},
+									"sort": {
+										"type": "array",
+										"description": "Sort keys, in priority order.",
+										"items": {
+											"type": "object",
+											"additionalProperties": false,
+											"required": ["key"],
+											"properties": {
+												"key": { "type": "string" },
+												"order": { "type": "string", "enum": ["asc", "desc"] }
+											}
+										}
+									},
+									"label": {
+										"type": "string",
+										"description": "One label for the control's label filter."
+									}
+								}
+							}
+						},
 						"splitCloseButton": {
 							"type": "boolean",
 							"default": true,
@@ -4574,13 +4621,32 @@
 							"description": "type='dashboard': page-level filter controls in the header. Each selection is written into the page's workspace context, so a widget reads it through a `@page.<key>` / `@workspace.<key>` token (an endpoint widget also in its `responsePath`). Maps to the CnDashboardPage `pageFilters` prop.",
 							"items": {
 								"type": "object",
-								"required": ["key", "options"],
+								"required": ["key"],
+								"anyOf": [{ "required": ["options"] }, { "required": ["optionsFrom"] }],
 								"additionalProperties": false,
 								"properties": {
 									"key": { "type": "string", "minLength": 1, "description": "Workspace-context key written on change (the `@page.<key>` / `@workspace.<key>` token name)." },
 									"label": { "type": "string", "description": "Control label (i18n key or plain text)." },
 									"type": { "type": "string", "enum": ["select"], "default": "select", "description": "Control type, carried over from v1." },
 									"control": { "type": "string", "enum": ["select", "segmented"], "default": "select", "description": "How the filter is drawn: a select, or a compact segmented group." },
+									"clearable": { "type": "boolean", "default": false, "description": "Lets the reader clear the select back to all; `placeholder` names that state (2.130.0)." },
+									"placeholder": { "type": "string", "description": "What a cleared select shows, e.g. \"All case types\", through the app's translate (2.130.0)." },
+									"optionsFrom": {
+										"type": "object",
+										"additionalProperties": false,
+										"description": "Read the options instead of listing them: from an app endpoint (`url`, `params`, `responsePath`) or from OpenRegister objects (`register`, `schema`, `filter`). `valueField` and `labelField` pick each option's value and label (default `id` and `title` or `name`); tokens resolve (2.130.0).",
+										"anyOf": [{ "required": ["url"] }, { "required": ["register", "schema"] }],
+										"properties": {
+											"url": { "type": "string", "minLength": 1 },
+											"params": { "type": "object", "additionalProperties": true },
+											"responsePath": { "type": "string", "minLength": 1 },
+											"register": { "type": "string", "minLength": 1 },
+											"schema": { "type": "string", "minLength": 1 },
+											"filter": { "type": "object", "additionalProperties": true },
+											"valueField": { "type": "string", "minLength": 1 },
+											"labelField": { "type": "string", "minLength": 1 }
+										}
+									},
 									"placement": { "type": "string", "enum": ["row", "description"], "default": "row", "description": "Where the filter sits: in the header's filter row, or (a segmented group) on the description line after the period group (DqProcesanalyse)." },
 									"default": { "type": ["string", "number"], "description": "Initial value seeded into the context on mount; the first option's value when omitted." },
 									"options": {
@@ -4916,6 +4982,35 @@
 									"type": "boolean",
 									"default": true,
 									"description": "Whether coincident markers are grouped into a cluster that spiderfies on click. ON by default here — the opposite of CnMapWidget's own default — because an index map plots whatever the filter returns, and several rows at one address is the normal case: unclustered they land on identical pixels, the topmost takes every click and the rest are unreachable with nothing on screen saying they exist. Non-point geometry skips the cluster group, so areas are unaffected. Set false for the old behaviour."
+								},
+								"markerColor": {
+									"type": "object",
+									"required": ["field"],
+									"additionalProperties": false,
+									"description": "Colour each marker by a field of its row. Without `source` the value is looked up in `colorMap`; with `source` the field is a reference and the referenced row's `colorField` is the colour, or the key `colorMap` maps to one. A value nothing maps to gets `default`, else the map's own colour.",
+									"properties": {
+										"field": { "type": "string", "description": "The row field (dotted path, also under `@self`)." },
+										"colorMap": { "type": "object", "additionalProperties": { "type": "string" }, "description": "Value (or source colour key) to CSS colour; `var(--x, #fallback)` is resolved for the SVG marker." },
+										"source": {
+											"type": "object",
+											"required": ["colorField"],
+											"properties": {
+												"register": { "type": "string" },
+												"schema": { "type": "string" },
+												"colorField": { "type": "string" },
+												"filter": { "type": "object" }
+											}
+										},
+										"default": { "type": "string" }
+									}
+								},
+								"plotAll": {
+									"oneOf": [{ "type": "boolean" }, { "type": "integer", "minimum": 1 }],
+									"description": "Plot every row that matches the filters instead of the current page: `true` for up to 500, or a number. When more rows match, a note under the map says the first N are shown."
+								},
+								"count": {
+									"oneOf": [{ "type": "boolean" }, { "type": "string" }],
+									"description": "A count line under the map: `true` for \"Showing {located} of {total} located\", or a template with `{located}` and `{total}` through the app's translate."
 								}
 							}
 						},

package/src/utils/actionsDispatcher.js

@@ -51,6 +51,7 @@ import { translate as t } from '@nextcloud/l10n'
 import { parseDispositionFilename, triggerBlobDownload } from '../components/CnIndexPage/selfModeIO.js'
 import { interpolateUrlTokens } from '../composables/useEndpointSource.js'
 import { routeHref } from './actionLink.js'
+import { resolveModalEntry } from './builtInModals.js'
 import {
 	dropOptionalUnresolved,
 	dropOptionalUnresolvedDeep,
@@ -836,8 +837,7 @@ export function dispatchAction(action, context = {}) {
 
 		case 'open-modal': {
 			const target = action.target
-			const registry = context.registry || {}
-			const entry = registry[target]
+			const entry = resolveModalEntry(context.registry, target)
 
 			if (!entry) {
 			// eslint-disable-next-line no-console

package/src/utils/builtInModals.js

@@ -0,0 +1,35 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * Modals every app can open by name with an `open-modal` action, without
+ * registering them. An app's own registry entry of the same name wins.
+ *
+ * @module utils/builtInModals
+ */
+
+import { defineAsyncComponent } from 'vue'
+
+/**
+ * The built-in modals, as registry entries (`{ kind: 'modal', component }`):
+ * `CnActionDialog`, the generic summary, checklist, reason and confirm dialog,
+ * its `config` in the action's `props`. Loaded on first open.
+ *
+ * @type {Readonly<Record<string, {kind: string, component: object}>>}
+ * @spec openspec/changes/action-dialog/specs/action-dialog/spec.md#requirement-a-manifest-configures-an-action-dialog
+ */
+export const BUILT_IN_MODALS = Object.freeze({
+	CnActionDialog: { kind: 'modal', component: defineAsyncComponent(() => import('../components/CnActionDialog/CnActionDialog.vue')) },
+})
+
+/**
+ * The registry entry for a modal name: the app's own, else a built-in one.
+ *
+ * @param {object|null} registry The app's registry.
+ * @param {string} name The modal's name.
+ * @return {object|null} The entry, or null.
+ */
+export function resolveModalEntry(registry, name) {
+	const own = registry && typeof registry === 'object' ? registry[name] : undefined
+	return own || BUILT_IN_MODALS[name] || null
+}

package/src/utils/mapMarkerColor.js

@@ -0,0 +1,117 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * mapMarkerColor — the colour of an index map's marker, read from a field of
+ * its row (`mapConfig.markerColor`).
+ *
+ * ```json
+ * "markerColor": {
+ *   "field": "status",
+ *   "colorMap": { "open": "#0b71ab", "closed": "var(--nl-color-grey, #696969)" },
+ *   "source": { "schema": "statusType", "colorField": "colour" },
+ *   "default": "#696969"
+ * }
+ * ```
+ *
+ * Without `source` the field's value is looked up in `colorMap`. With
+ * `source` the field holds a reference: the referenced row's `colorField`
+ * is the colour, or the key `colorMap` maps to one ("blue" -> a CSS colour).
+ * A value nothing maps to gets `default`, else no colour (the map's own).
+ *
+ * @module utils/mapMarkerColor
+ */
+
+import { refIdOf } from './boardReferenceColumns.js'
+
+/** A colour that can go into a style or an SVG attribute: no quotes, no `;`, no `url(`. */
+const SAFE_COLOR = /^(?!.*url\()[#a-zA-Z0-9(),.%\s_-]{1,120}$/
+
+/**
+ * The `markerColor` block in a usable shape, or null when it names no field.
+ *
+ * @param {unknown} cfg The configured block.
+ * @return {{field: string, colorMap: object, source: (object|null), fallback: string}|null} The block.
+ */
+export function normalizeMarkerColor(cfg) {
+	if (!cfg || typeof cfg !== 'object' || typeof cfg.field !== 'string' || cfg.field === '') {
+		return null
+	}
+	const source = cfg.source && typeof cfg.source === 'object' && typeof cfg.source.colorField === 'string' ? cfg.source : null
+	return {
+		field: cfg.field,
+		colorMap: cfg.colorMap && typeof cfg.colorMap === 'object' ? cfg.colorMap : {},
+		source,
+		fallback: typeof cfg.default === 'string' ? cfg.default : '',
+	}
+}
+
+/**
+ * Read a dotted path off a row, also under `@self`.
+ *
+ * @param {object} row The row.
+ * @param {string} path The path.
+ * @return {unknown} The value.
+ */
+function valueAt(row, path) {
+	const read = (base) => path.split('.').reduce((o, k) => (o === null || o === undefined ? undefined : o[k]), base)
+	const direct = read(row)
+	return direct === undefined && row && row['@self'] ? read(row['@self']) : direct
+}
+
+/**
+ * The marker colour of one row.
+ *
+ * @param {object} row The row.
+ * @param {object|null} cfg The normalised block (see {@link normalizeMarkerColor}).
+ * @param {Map<string, object>} [refsById] The source rows by id, when `cfg.source` is set.
+ * @return {string} A CSS colour, or '' for the map's own.
+ */
+export function markerColorOf(row, cfg, refsById) {
+	if (!cfg || !row) {
+		return ''
+	}
+	const raw = valueAt(row, cfg.field)
+	let key = ''
+	if (cfg.source) {
+		const ref = refsById && refsById.get(refIdOf(raw))
+		key = ref ? String(ref[cfg.source.colorField] ?? '') : ''
+	} else if (raw !== null && raw !== undefined && typeof raw !== 'object') {
+		key = String(raw)
+	}
+	let color
+	if (key !== '' && Object.hasOwn(cfg.colorMap, key)) {
+		color = String(cfg.colorMap[key])
+	} else if (key !== '' && cfg.source) {
+		color = key
+	} else {
+		color = cfg.fallback
+	}
+	return SAFE_COLOR.test(color) ? color : ''
+}
+
+/**
+ * Resolve `var(--name, fallback)` to a concrete colour, for an SVG
+ * attribute, where a custom property does not resolve.
+ *
+ * @param {string} color The colour.
+ * @param {Element} [root] The element whose custom properties count.
+ * @return {string} The colour without `var()`, or the input when it has none.
+ */
+export function resolveCssColor(color, root) {
+	const match = /^var\(\s*(--[\w-]+)\s*(?:,\s*(.+))?\)$/.exec(String(color || '').trim())
+	if (!match) {
+		return color
+	}
+	let value
+	try {
+		const el = root || (typeof document !== 'undefined' ? document.documentElement : null)
+		value = el && typeof getComputedStyle === 'function' ? getComputedStyle(el).getPropertyValue(match[1]).trim() : ''
+	} catch {
+		value = ''
+	}
+	if (value !== '') {
+		return value
+	}
+	return match[2] ? resolveCssColor(match[2].trim(), root) : ''
+}

package/src/utils/mergeManifestDelta.js

@@ -45,6 +45,10 @@ export const KEYED_ARRAYS = Object.freeze({
 	// (or a backend `/api/manifest` override) can add/patch/remove individual
 	// children of a group without replacing the whole `children[]` array.
 	children: 'id',
+	// An index page's default views merge by `slug`, so the per-user delta
+	// (`/api/manifest`) can add a user's own defaults (dossiq's case type
+	// pins) without wiping the defaults the page ships.
+	defaultSavedViews: 'slug',
 })
 
 /** Reserved delta markers — never part of a base manifest. */

package/src/utils/savedViewHelpers.js

@@ -213,22 +213,30 @@ export function buildViewCreatePayload({ name, description, isPublic, isDefault,
 }
 
 /**
- * Clean an audience list: keep `{ group, mode }` entries with a group id, and
- * coerce any mode but `write` to `read`.
+ * Clean an audience list: keep `{ group, mode }` and `{ user, mode }` entries
+ * that name exactly one target, drop repeats, and coerce any mode but `write`
+ * to `read`.
  *
  * @param {unknown} sharedWith The audience as given.
- * @return {Array<{group: string, mode: 'read'|'write'}>} The cleaned list.
+ * @return {Array<{group?: string, user?: string, mode: 'read'|'write'}>} The cleaned list.
+ * @spec openspec/changes/saved-views-manage-and-defaults/tasks.md#task-5
  */
 export function normalizeSharedWith(sharedWith) {
 	const seen = new Set()
 	const out = []
 	for (const entry of Array.isArray(sharedWith) ? sharedWith : []) {
 		const group = entry && typeof entry.group === 'string' ? entry.group : ''
-		if (group === '' || seen.has(group)) {
+		const user = entry && typeof entry.user === 'string' ? entry.user : ''
+		if ((group === '') === (user === '')) {
 			continue
 		}
-		seen.add(group)
-		out.push({ group, mode: entry.mode === 'write' ? 'write' : 'read' })
+		const key = user !== '' ? `user:${user}` : `group:${group}`
+		if (seen.has(key)) {
+			continue
+		}
+		seen.add(key)
+		const mode = entry.mode === 'write' ? 'write' : 'read'
+		out.push(user !== '' ? { user, mode } : { group, mode })
 	}
 	return out
 }
@@ -376,3 +384,47 @@ export function extractViewState(view) {
 export function isOwnView(view, currentUserId) {
 	return !!view && !!currentUserId && view.owner === currentUserId
 }
+
+/**
+ * The default views an index page declares (`config.defaultSavedViews`), as
+ * read-only views the saved-views control lists. They are never stored: the
+ * manifest installs them, so every user has the same set and none can delete
+ * one. `seeded: true` puts them in the control's default group; the query
+ * keeps its `@`-tokens, which resolve when a default is applied.
+ *
+ * @param {Array<object>|null|undefined} defaults The declared entries `{ slug, name, filters, search?, sort?, label? }`.
+ * @param {{ scope?: string, register?: string, schema?: object|string|null }} [page] The page, as `savedViewScope` takes it.
+ * @return {Array<object>} The views, in declaration order; entries without a slug or name are left out.
+ * @spec openspec/changes/saved-views-manage-and-defaults/tasks.md#task-4
+ */
+export function defaultFilterViews(defaults, page = {}) {
+	if (!Array.isArray(defaults)) {
+		return []
+	}
+	return defaults
+		.filter((entry) => entry && typeof entry.slug === 'string' && entry.slug !== '' && typeof entry.name === 'string' && entry.name !== '')
+		.map((entry) => {
+			const { query } = buildViewCreatePayload({
+				name: entry.name,
+				state: {
+					filters: (entry.filters && typeof entry.filters === 'object' && !Array.isArray(entry.filters)) ? entry.filters : {},
+					search: typeof entry.search === 'string' ? entry.search : '',
+					sortKeys: Array.isArray(entry.sort) ? entry.sort : [],
+				},
+				scope: savedViewScope(page),
+				register: page.register,
+				schema: page.schema,
+			})
+			return {
+				id: `default:${entry.slug}`,
+				slug: entry.slug,
+				name: entry.name,
+				owner: '',
+				seeded: true,
+				isPublic: false,
+				labels: typeof entry.label === 'string' && entry.label !== '' ? [entry.label] : [],
+				'@self': { access: 'read' },
+				query,
+			}
+		})
+}