@conduction/nextcloud-vue 2.65.0 → 2.67.0

package/src/mixins/pageViews.js

@@ -0,0 +1,396 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * Page views: a few views of one page, each its own widget grid, behind one
+ * segmented control ("My work | My team").
+ *
+ * A page that mixes this in accepts `views` (each `{ id, label, icon?,
+ * widgets, layout, emptyText? }`), `defaultView` and `viewsLabel`. It keeps
+ * the chosen view, writes it to the address (`?view=<id>`) and to the
+ * user's preferences (the server, mirrored in the browser), and provides `cnPageViews` so a greeting header widget on
+ * the page can draw the switch instead of the page.
+ *
+ * Which view opens: the address, then the stored view, then `defaultView`,
+ * then the first view. An id that names no view is ignored at every step.
+ *
+ * Used by CnDashboardPage and CnDetailPage. Each renders the chosen view's
+ * `layout` with its own grid, so a view looks exactly like the page's own
+ * grid.
+ *
+ * @mixin pageViews
+ * @spec openspec/changes/view-switch-containers/specs/view-switch-containers/spec.md#requirement-a-page-declares-views-that-each-hold-a-widget-grid
+ */
+import { translate as t } from '@nextcloud/l10n'
+import { readUserPreference, USER_PREFERENCE_STORAGE_PREFIX, writeUserPreference } from '../composables/useUserPreferences.js'
+
+/** The query parameter that carries the chosen view. */
+export const PAGE_VIEW_QUERY_KEY = 'view'
+
+/** Prefix of the user-preference key; the page id follows it. */
+export const PAGE_VIEW_PREFERENCE_PREFIX = 'cn_page_view:'
+
+let regionSeq = 0
+
+/**
+ * Read the browser mirror of a user preference synchronously, so the stored
+ * view is on screen from the first frame. Errors read as nothing stored.
+ *
+ * @param {string} appId The app id.
+ * @param {string} key The preference key.
+ * @return {string|null} The stored id, or null.
+ * @spec openspec/changes/view-switch-containers/specs/view-switch-containers/spec.md#requirement-the-chosen-view-is-linkable-and-remembered
+ */
+function readStoredViewMirror(appId, key) {
+	try {
+		if (typeof localStorage === 'undefined') {
+			return null
+		}
+		const raw = localStorage.getItem(`${USER_PREFERENCE_STORAGE_PREFIX}${appId}:${key}`)
+		if (raw === null || raw === undefined) {
+			return null
+		}
+		const value = JSON.parse(raw)
+		return typeof value === 'string' && value !== '' ? value : null
+	} catch {
+		return null
+	}
+}
+
+export const pageViews = {
+	inject: {
+		/** The host app id, provided by CnAppRoot; keys the stored view. */
+		cnPageViewsAppId: { from: 'cnAppId', default: '' },
+	},
+
+	props: {
+		/**
+		 * Views of this page, each its own widget grid behind one segmented
+		 * control. Each is `{ id, label, icon?, widgets, layout, emptyText? }`:
+		 * `widgets` and `layout` have the same shape as the page's own. The
+		 * chosen view renders in a region below the page's own grid. Empty
+		 * (the default) draws no switch and no region.
+		 *
+		 * @type {Array<{id: string, label: string, icon?: string, widgets?: Array<object>, layout?: Array<object>, emptyText?: string}>}
+		 */
+		views: {
+			type: Array,
+			default: () => [],
+		},
+
+		/**
+		 * The id of the view chosen when neither the address nor the browser
+		 * store names one. Empty chooses the first view.
+		 *
+		 * @type {string}
+		 */
+		defaultView: {
+			type: String,
+			default: '',
+		},
+
+		/**
+		 * Accessible name of the view switch (through the host translate
+		 * function). Empty reads "View".
+		 *
+		 * @type {string}
+		 */
+		viewsLabel: {
+			type: String,
+			default: '',
+		},
+	},
+
+	data() {
+		regionSeq += 1
+		return {
+			/** The view the user chose in this session, or the stored one. */
+			selectedViewId: null,
+			/** Whether the user chose a view in this session (a late server read then leaves it alone). */
+			viewChosen: false,
+			/** Id of the view region, the target of the options' `aria-controls`. */
+			viewRegionId: `cn-page-view-region-${regionSeq}`,
+		}
+	},
+
+	/**
+	 * Provide the views to descendants, so a greeting header widget in the
+	 * page's grid can draw the switch. Getters keep it reactive.
+	 *
+	 * @return {object} The provided `cnPageViews`.
+	 */
+	provide() {
+		const vm = this
+		return {
+			cnPageViews: {
+				get views() { return vm.normalizedViews },
+				get activeId() { return vm.activeViewId },
+				get regionId() { return vm.viewRegionId },
+				select: (id) => vm.selectView(id),
+			},
+		}
+	},
+
+	computed: {
+		/**
+		 * The declared views in one shape, labels translated. Entries without
+		 * an id or a label are dropped, as are repeated ids.
+		 *
+		 * @return {Array<{id: string, label: string, icon: string, widgets: Array<object>, layout: Array<object>, emptyText: string}>}
+		 * @spec openspec/changes/view-switch-containers/specs/view-switch-containers/spec.md#requirement-a-page-declares-views-that-each-hold-a-widget-grid
+		 */
+		normalizedViews() {
+			const translate = typeof this.cnTranslate === 'function' ? this.cnTranslate : (key) => key
+			const seen = new Set()
+			return (Array.isArray(this.views) ? this.views : [])
+				.filter((view) => {
+					if (!view || typeof view !== 'object' || view.id === undefined || view.id === null || view.id === '') {
+						return false
+					}
+					if (typeof view.label !== 'string' || view.label === '' || seen.has(String(view.id))) {
+						return false
+					}
+					seen.add(String(view.id))
+					return true
+				})
+				.map((view) => ({
+					id: String(view.id),
+					label: translate(view.label),
+					icon: typeof view.icon === 'string' ? view.icon : '',
+					widgets: Array.isArray(view.widgets) ? view.widgets : [],
+					layout: Array.isArray(view.layout) ? view.layout : [],
+					emptyText: typeof view.emptyText === 'string' && view.emptyText !== '' ? translate(view.emptyText) : '',
+				}))
+		},
+
+		/**
+		 * Whether this page has views.
+		 *
+		 * @return {boolean}
+		 */
+		hasViews() {
+			return this.normalizedViews.length > 0
+		},
+
+		/**
+		 * The chosen view's id: the address, then this session's or the
+		 * stored choice, then `defaultView`, then the first view.
+		 *
+		 * @return {string|null} The id, or null without views.
+		 * @spec openspec/changes/view-switch-containers/specs/view-switch-containers/spec.md#requirement-the-chosen-view-is-linkable-and-remembered
+		 */
+		activeViewId() {
+			const views = this.normalizedViews
+			if (views.length === 0) {
+				return null
+			}
+			const known = (id) => id !== null && id !== undefined && views.some((view) => view.id === String(id))
+			const fromAddress = this.$route && this.$route.query ? this.$route.query[PAGE_VIEW_QUERY_KEY] : undefined
+			if (known(fromAddress)) {
+				return String(fromAddress)
+			}
+			if (known(this.selectedViewId)) {
+				return String(this.selectedViewId)
+			}
+			if (known(this.defaultView)) {
+				return this.defaultView
+			}
+			return views[0].id
+		},
+
+		/**
+		 * The chosen view, or null without views.
+		 *
+		 * @return {object|null}
+		 */
+		activeView() {
+			return this.normalizedViews.find((view) => view.id === this.activeViewId) || null
+		},
+
+		/**
+		 * The switch's options, for CnSegmentedControl.
+		 *
+		 * @return {Array<{value: string, label: string}>}
+		 */
+		viewSwitchOptions() {
+			return this.normalizedViews.map((view) => ({ value: view.id, label: view.label }))
+		},
+
+		/**
+		 * The switch's accessible name: `viewsLabel` translated, else "View".
+		 *
+		 * @return {string}
+		 * @spec openspec/changes/view-switch-containers/specs/view-switch-containers/spec.md#requirement-the-view-switch-is-accessible
+		 */
+		viewSwitchLabel() {
+			const translate = typeof this.cnTranslate === 'function' ? this.cnTranslate : (key) => key
+			return this.viewsLabel ? translate(this.viewsLabel) : t('nextcloud-vue', 'Views')
+		},
+
+		/**
+		 * Whether a greeting header in the page's own widgets draws the
+		 * switch (an option with a `view`), so the page draws none.
+		 *
+		 * @return {boolean}
+		 * @spec openspec/changes/view-switch-containers/specs/view-switch-containers/spec.md#requirement-a-greeting-header-can-switch-the-pages-views
+		 */
+		viewSwitchInHeaderWidget() {
+			const widgets = Array.isArray(this.widgets) ? this.widgets : []
+			return widgets.some((def) => {
+				const options = def && def.content && def.content.views && def.content.views.options
+				return Array.isArray(options) && options.some((option) => option && typeof option.view === 'string' && option.view !== '')
+			})
+		},
+
+		/**
+		 * Whether the page draws the switch itself.
+		 *
+		 * @return {boolean}
+		 */
+		showsPageViewSwitch() {
+			return this.hasViews && !this.viewSwitchInHeaderWidget
+		},
+
+		/**
+		 * The user-preference key for this page's chosen view.
+		 *
+		 * @return {string}
+		 */
+		viewPreferenceKey() {
+			// The page id, else the route name: a detail page's fallback id is
+			// its record's title, which would remember a view per record.
+			const id = this.pageId || (this.$route && this.$route.name) || this.resolvedPageId || 'page'
+			return `${PAGE_VIEW_PREFERENCE_PREFIX}${id}`
+		},
+
+		/**
+		 * The app id the stored view is kept under: the page's `appId` prop
+		 * when it has one, else the app root's.
+		 *
+		 * @return {string}
+		 */
+		viewPreferenceAppId() {
+			const own = typeof this.appId === 'string' ? this.appId : ''
+			return own || (typeof this.cnPageViewsAppId === 'string' ? this.cnPageViewsAppId : '')
+		},
+
+		/**
+		 * The message of the chosen view's empty state.
+		 *
+		 * @return {string}
+		 * @spec openspec/changes/view-switch-containers/specs/view-switch-containers/spec.md#requirement-a-view-with-nothing-to-draw-says-so
+		 */
+		viewEmptyText() {
+			if (this.activeView && this.activeView.emptyText) {
+				return this.activeView.emptyText
+			}
+			return t('nextcloud-vue', 'This view has no widgets yet.')
+		},
+	},
+
+	created() {
+		this.loadStoredView()
+	},
+
+	methods: {
+		/**
+		 * Read the stored view: the browser mirror at once, then the user
+		 * preference on the server, which wins unless the user already chose.
+		 *
+		 * @return {Promise<void>}
+		 * @spec openspec/changes/view-switch-containers/specs/view-switch-containers/spec.md#requirement-the-chosen-view-is-linkable-and-remembered
+		 */
+		async loadStoredView() {
+			if (!this.hasViews) {
+				return
+			}
+			const appId = this.viewPreferenceAppId
+			const key = this.viewPreferenceKey
+			this.selectedViewId = readStoredViewMirror(appId, key)
+			if (!appId) {
+				return
+			}
+			const stored = await readUserPreference(appId, key, null)
+			if (!this.viewChosen && typeof stored === 'string' && stored !== '') {
+				this.selectedViewId = stored
+			}
+		},
+
+		/**
+		 * Choose a view: keep it, store it, and write it to the address
+		 * (replacing the history entry, keeping the other query keys).
+		 *
+		 * @param {string} id The view id.
+		 * @return {void}
+		 * @spec openspec/changes/view-switch-containers/specs/view-switch-containers/spec.md#requirement-the-chosen-view-is-linkable-and-remembered
+		 */
+		selectView(id) {
+			const view = this.normalizedViews.find((candidate) => candidate.id === String(id))
+			if (!view) {
+				return
+			}
+			this.selectedViewId = view.id
+			this.viewChosen = true
+			writeUserPreference(this.viewPreferenceAppId, this.viewPreferenceKey, view.id)
+			if (!this.$router || !this.$route) {
+				return
+			}
+			const query = this.$route.query || {}
+			if (query[PAGE_VIEW_QUERY_KEY] === view.id) {
+				return
+			}
+			const result = this.$router.replace({ query: { ...query, [PAGE_VIEW_QUERY_KEY]: view.id } })
+			if (result && typeof result.catch === 'function') {
+				result.catch(() => {})
+			}
+		},
+
+		/**
+		 * Look a widget definition up in the views, for a layout item of the
+		 * chosen view.
+		 *
+		 * @param {string} widgetId The widget id.
+		 * @return {object|null} The definition, or null.
+		 */
+		findViewWidget(widgetId) {
+			const view = this.activeView
+			if (!view) {
+				return null
+			}
+			return view.widgets.find((def) => def && def.id === widgetId) || null
+		},
+
+		/**
+		 * Write a drag or resize in the chosen view's grid back onto its
+		 * layout items in place, as the page does for its own layout, so the
+		 * in-app manifest editor sees it.
+		 *
+		 * @param {Array<object>} updated The layout from the grid.
+		 * @return {void}
+		 */
+		onViewLayoutChange(updated) {
+			const view = this.activeView
+			if (!view || !Array.isArray(updated)) {
+				return
+			}
+			for (const u of updated) {
+				const item = view.layout.find((l) => String(l.id) === String(u.id))
+				if (!item) {
+					continue
+				}
+				for (const key of ['gridX', 'gridY', 'gridWidth', 'gridHeight']) {
+					if (u[key] !== undefined) {
+						item[key] = u[key]
+					}
+				}
+			}
+			/**
+			 * Emitted when a widget in a view's grid is dragged or resized.
+			 *
+			 * @event view-layout-change
+			 * @type {{view: string, layout: Array<object>}}
+			 */
+			this.$emit('view-layout-change', { view: view.id, layout: view.layout })
+		},
+	},
+}

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.47.0",
+	"version": "2.49.0",
 	"type": "object",
 	"required": ["$schema", "version"],
 	"allOf": [
@@ -98,7 +98,7 @@
 							"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." },
+							"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. Setup status then counts the step as not applicable, neither met nor unmet, so it never reopens the wizard or gates the app. This holds for a required step too." },
 							"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." },
@@ -236,7 +236,7 @@
 				},
 				"settingsLabel": {
 					"type": "string",
-					"description": "Override label for the settings foldout's gear button. Defaults to 'Settings'."
+					"description": "Override label for the settings foldout's gear button. Defaults to 'Advanced'."
 				},
 				"card": {
 					"type": "object",
@@ -3608,6 +3608,34 @@
 							"default": true,
 							"description": "type='dashboard': `false` drops the header row (title, description, header actions, edit toggle) for a page that opens with its own heading, such as a greeting widget; the title stays as a visually hidden heading (zuiddrecht-pixel-gaps). Maps to CnDashboardPage `showHeader`."
 						},
+						"views": {
+							"type": "array",
+							"minItems": 1,
+							"description": "type='dashboard' | type='detail': views of the page, each its own widget grid behind one segmented control (\"My work | My team\") (view-switch-containers). The chosen view renders in a region below the page's own grid, drawn with the same grid and widgets; the page's own `widgets` and `layout` stay above it. The switch sits in the page header, or in a greeting header widget whose `content.views.options[]` carry `view` instead of `route`. The chosen view is in the address (`?view=<id>`) and in the user's preferences; the address wins. A view with nothing to draw shows `emptyText`, else a default sentence. On a detail page, views replace the automatic Data and Related body. Maps to CnDashboardPage / CnDetailPage `views`.",
+							"items": {
+								"type": "object",
+								"required": ["id", "label"],
+								"additionalProperties": false,
+								"properties": {
+									"id": { "type": "string", "minLength": 1, "pattern": "^[A-Za-z0-9_-]+$", "description": "The view id, written to the address as `?view=<id>`." },
+									"label": { "type": "string", "minLength": 1, "description": "The option label and the region's accessible name (through the app's translations)." },
+									"icon": { "type": "string", "minLength": 1, "description": "Optional MDI icon name, reserved for an icon-bearing switch." },
+									"emptyText": { "type": "string", "minLength": 1, "description": "The sentence shown when the view has nothing to draw." },
+									"widgets": { "type": "array", "description": "The view's widget definitions, the same shape as the page's `widgets`.", "items": { "type": "object", "additionalProperties": true } },
+									"layout": { "type": "array", "description": "The view's grid layout, the same shape as the page's `layout`.", "items": { "type": "object", "additionalProperties": true } }
+								}
+							}
+						},
+						"defaultView": {
+							"type": "string",
+							"minLength": 1,
+							"description": "type='dashboard' | type='detail': the id of the view chosen when neither the address nor the user's stored choice names one; without it the first view (view-switch-containers). Maps to `defaultView`."
+						},
+						"viewsLabel": {
+							"type": "string",
+							"minLength": 1,
+							"description": "type='dashboard' | type='detail': the accessible name of the page's view switch, e.g. \"Whose work\"; defaults to \"View\" (view-switch-containers). Maps to `viewsLabel`."
+						},
 						"showWidgetActions": {
 							"type": "boolean",
 							"default": true,

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

@@ -50,7 +50,7 @@
 				},
 				"settingsLabel": {
 					"type": "string",
-					"description": "Override label for the settings foldout's gear button. Defaults to 'Settings'."
+					"description": "Override label for the settings foldout's gear button. Defaults to 'Advanced'."
 				},
 				"primaryAction": {
 					"$ref": "#/$defs/primaryAction",

package/src/store/plugins/liveUpdates.js

@@ -432,19 +432,29 @@ export function liveUpdatesPlugin(opts = {}) {
 			const collectionInFlight = new Map()
 
 			const originalFetchCollection = store.fetchCollection.bind(store)
-			store.fetchCollection = async function dedupedFetchCollection(type, params = {}) {
+			store.fetchCollection = async function dedupedFetchCollection(type, params = {}, options = {}) {
 				if (!store.__liveDedupActive) {
-					return originalFetchCollection(type, params)
+					return originalFetchCollection(type, params, options)
 				}
 				const key = collectionDedupKey(type, params)
-				if (collectionInFlight.has(key)) {
-					return collectionInFlight.get(key)
+				let entry = collectionInFlight.get(key)
+				if (!entry) {
+					// The shared request reports into its own sink, copied to
+					// each caller's `options.outcome` below, so a caller that
+					// joined it learns that request's result too.
+					const outcome = {}
+					const promise = originalFetchCollection(type, params, { ...options, outcome }).finally(() => {
+						collectionInFlight.delete(key)
+					})
+					entry = { promise, outcome }
+					collectionInFlight.set(key, entry)
 				}
-				const promise = originalFetchCollection(type, params).finally(() => {
-					collectionInFlight.delete(key)
-				})
-				collectionInFlight.set(key, promise)
-				return promise
+				const results = await entry.promise
+				const sink = options && options.outcome
+				if (sink && typeof sink === 'object' && 'error' in entry.outcome) {
+					sink.error = entry.outcome.error
+				}
+				return results
 			}
 		},
 	}

package/src/store/useObjectStore.js

@@ -656,9 +656,12 @@ const baseActions = {
 	 *
 	 * @param {string} type The registered type slug
 	 * @param {object} [params] Query parameters (_limit, _page, _search, _order, filters)
+	 * @param {object} [options] Call options
+	 * @param {{error?: object|null}} [options.outcome] Opt-in sink for THIS call's own result: `error` is set to the error it records on `errors[type]`, or `null` on success. Unlike `errors[type]`, which every call for the type shares, a later call cannot overwrite it.
 	 * @return {Promise<Array>} The fetched collection (also stored in state)
 	 */
-	async fetchCollection(type, params = {}) {
+	async fetchCollection(type, params = {}, options = {}) {
+		const outcome = (options && typeof options.outcome === 'object' && options.outcome) || null
 		this.loading = { ...this.loading, [type]: true }
 		this.errors = { ...this.errors, [type]: null }
 
@@ -685,9 +688,13 @@ const baseActions = {
 			)
 
 			if (!response.ok) {
-				this.errors = { ...this.errors, [type]: await parseResponseError(response, type) }
+				const failure = await parseResponseError(response, type)
+				this.errors = { ...this.errors, [type]: failure }
+				if (outcome) {
+					outcome.error = failure
+				}
 				// eslint-disable-next-line no-console -- diagnostic for a failure this code already degrades from
-				console.error(`Error fetching ${type} collection:`, this.errors[type])
+				console.error(`Error fetching ${type} collection:`, failure)
 				return []
 			}
 
@@ -711,13 +718,17 @@ const baseActions = {
 				this.facets = { ...this.facets, [type]: transformed }
 			}
 
+			if (outcome) {
+				outcome.error = null
+			}
 			return results
 		} catch (error) {
-			this.errors = {
-				...this.errors,
-				[type]: error.name === 'TypeError'
-					? networkError(error)
-					: genericError(error),
+			const failure = error.name === 'TypeError'
+				? networkError(error)
+				: genericError(error)
+			this.errors = { ...this.errors, [type]: failure }
+			if (outcome) {
+				outcome.error = failure
 			}
 			// eslint-disable-next-line no-console -- diagnostic for a failure this code already degrades from
 			console.error(`Error fetching ${type} collection:`, error)

package/src/utils/actionsDispatcher.js

@@ -100,6 +100,14 @@ export function isExternalActionTarget(target) {
  * would otherwise register — and fetch — a 404 (defect 7, learniq round
  * 1). Idempotent for a caller that already passes a correct slug.
  *
+ * A caller that already holds the schema SLUG (not a `$ref` title) passes
+ * `{ exactSchema: true }`: the slug is then used exactly as given. Kebab-casing
+ * a real camelCase slug (`productCategory` -> `product-category`) asks the
+ * objects API for a schema that does not exist and 404s (pipelinq review,
+ * round two).
+ *
+ * @spec openspec/changes/review-round-two/specs/schema-utilities/spec.md
+ *
  * A title is not always registered under its kebab form: learniq holds
  * `LearniqSettings` and `SubjectTeacherAssignment` as written. So a type
  * registered here for a value the kebab rule CHANGED also carries the value
@@ -110,11 +118,12 @@ export function isExternalActionTarget(target) {
  * @spec openspec/changes/zuiddrecht-pixel-gaps-2/specs/zuiddrecht-pixel-gaps-2/spec.md#requirement-a-schema-title-falls-back-to-its-written-form
  * @param {object} store The object store instance (useObjectStore shape).
  * @param {{register: (string|number), schema: (string|number)}} source The widget source.
+ * @param {{exactSchema: (boolean|undefined)}} [options] `exactSchema: true` skips the title-to-slug step.
  * @return {string} The type slug to use for store CRUD calls.
  */
-export function resolveObjectOpType(store, source) {
+export function resolveObjectOpType(store, source, options = {}) {
 	const register = String(source.register)
-	const schema = String(schemaRefSlug(source.schema))
+	const schema = options.exactSchema === true ? String(source.schema) : String(schemaRefSlug(source.schema))
 	const written = typeof source.schema === 'string'
 		? source.schema.substring(source.schema.lastIndexOf('/') + 1)
 		: ''

package/src/utils/columnFilters.js

@@ -15,13 +15,19 @@
  * Parameter shapes, as OpenRegister reads them:
  * - equality and "any of": `key=value`, `key[]=a&key[]=b`
  * - ranges: `key[gte]=from`, `key[lte]=to`
+ * - contains (text): `key[like]=term`, case-insensitive (openregister#4430);
+ *   the server escapes `%`, `_` and `\`, so the raw term goes out as typed
  *
  * @module utils/columnFilters
  * @spec openspec/changes/table-header-sort-and-filter/specs/cn-data-table/spec.md
+ * @spec openspec/changes/header-filter-contains/specs/cn-data-table/spec.md#requirement-a-text-header-filter-matches-on-contains
  */
 
 import { schemaRefSlug } from './schemaRefSlug.js'
 
+/** OpenRegister's case-insensitive contains operator, used by the text filter. */
+export const CONTAINS_OPERATOR = 'like'
+
 /** Column keys that mark a value computed on the client, never stored. */
 const COMPUTED_MARKERS = ['aggregate', 'compute', 'computed', 'virtual']
 
@@ -160,7 +166,7 @@ function referenceTarget(column, prop) {
  *
  * 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
+ * to), and `string` (contains, through OpenRegister's `[like]`). `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.
@@ -234,9 +240,25 @@ export function columnFilterParamKeys(def) {
 	if (def.kind === 'number' || def.kind === 'date') {
 		return [`${def.key}[gte]`, `${def.key}[lte]`]
 	}
+	if (def.kind === 'string') {
+		return [containsKey(def)]
+	}
 	return [def.key]
 }
 
+/**
+ * The parameter a text filter writes: `{key}[like]`. An exact `key=value`
+ * from the facet sidebar or a fixed filter is a different key, so the header
+ * neither shows nor clears it.
+ *
+ * @param {object} def A filter definition of kind `string`.
+ * @return {string} The parameter key.
+ * @spec openspec/changes/header-filter-contains/specs/cn-data-table/spec.md#requirement-a-text-header-filter-matches-on-contains
+ */
+function containsKey(def) {
+	return `${def.key}[${CONTAINS_OPERATOR}]`
+}
+
 /**
  * A column filter's current state, read from the active-filter map.
  *
@@ -262,6 +284,9 @@ export function columnFilterState(def, activeFilters) {
 			to: def.kind === 'date' ? to.slice(0, 10) : to,
 		}
 	}
+	if (def.kind === 'string') {
+		return { value: asList(filters[containsKey(def)])[0] || '' }
+	}
 	return { value: asList(filters[def.key])[0] || '' }
 }
 
@@ -309,8 +334,10 @@ export function columnFilterParams(def, state) {
 	if (def.kind === 'boolean') {
 		return { [def.key]: (s.value === 'true' || s.value === 'false') ? [s.value] : [] }
 	}
+	// Text: the raw term under `[like]`. No wildcards: OpenRegister wraps
+	// the term itself and escapes `%`, `_` and `\` in it.
 	const value = s.value === undefined || s.value === null ? '' : String(s.value).trim()
-	return { [def.key]: value === '' ? [] : [value] }
+	return { [containsKey(def)]: value === '' ? [] : [value] }
 }
 
 /**