@conduction/nextcloud-vue 2.80.0 → 2.81.0

package/src/utils/objectWrite.js

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

package/src/utils/pageControls.js

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

package/src/utils/personalLenses.js

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

package/src/utils/resolveFilterTokens.js

@@ -67,7 +67,9 @@
 
 import { getCurrentUser } from '@nextcloud/auth'
 import { TODAY_DELTA_RE } from './sentinelTokens.js'
-import { peekCurrentUserGroups } from './widgetVisibility.js'
+// userGroupsPeek, not widgetVisibility: that one imports @nextcloud/axios, and
+// this resolver runs on public pages and in node (see userGroupsPeek.js).
+import { peekCurrentUserGroups } from './userGroupsPeek.js'
 
 /** The filter token for the current user's group ids. */
 export const MY_GROUPS_TOKEN = '@myGroups'

package/src/utils/resolveManifestTokens.js

@@ -54,6 +54,8 @@ export const SENTINEL_RESOLVERS = Object.freeze({
 	declarative: 'fetchAggregate (OpenRegister server-side)',
 	visibleWhen: 'evaluateVisibleWhen (utils/visibleWhen.js)',
 	answer: 'resolveAssignValue (utils/formAssign.js)',
+	row: 'CnFieldListWidget (rowActions request)',
+	subject: 'CnBannerWidget (action route)',
 })
 
 /**

package/src/utils/sentinelTokens.js

@@ -83,6 +83,12 @@ export const SENTINEL_TOKEN_PATTERNS = Object.freeze({
 	visibleWhen: '^@total$',
 	// form-live-values: another answer in the same form, read by a field's `assign` rule.
 	answer: '^@answer\\.[A-Za-z][A-Za-z0-9_]*$',
+	// A field of the row a row action is run on (`@row.<field>`, dot path), read by the
+	// field-list widget's `rowActions` request URL and payload.
+	row: '^@row\\.[A-Za-z][A-Za-z0-9_.@]*$',
+	// A field of the record a start-here attention card names (`@subject.<field>`, dot path),
+	// read by the banner widget's action routes.
+	subject: '^@subject\\.[A-Za-z][A-Za-z0-9_.]*$',
 	// Deprecated-but-not-yet-removed tokens. Kept in the schema union so
 	// deployed manifests still validate during the migration window; the gate
 	// downgrades them to a WARN (see SENTINEL_DEPRECATIONS).
@@ -90,7 +96,7 @@ export const SENTINEL_TOKEN_PATTERNS = Object.freeze({
 })
 
 /**
- * The eight canonical context names (excludes `deprecated`, which is a
+ * The nine canonical context names (excludes `deprecated`, which is a
  * transitional overlay, not a resolution context).
  *
  * @type {string[]}
@@ -104,6 +110,8 @@ export const SENTINEL_CONTEXTS = Object.freeze([
 	'declarative',
 	'visibleWhen',
 	'answer',
+	'row',
+	'subject',
 ])
 
 /**
@@ -154,6 +162,16 @@ export const SENTINEL_VOCABULARY = Object.freeze({
 		description: 'Another answer in the same form, read by a field\'s `assign` rule.',
 		members: ['@answer.<field>'],
 	},
+	row: {
+		resolver: 'CnFieldListWidget (rowActions request url and payload)',
+		description: 'A field of the row a row action runs on, read by the field-list widget when it sends the action\'s request. Dot paths are allowed (`@row.owner.id`).',
+		members: ['@row.<field>'],
+	},
+	subject: {
+		resolver: 'CnBannerWidget (action route params and query)',
+		description: 'A field of the record an attention card names (the first row of its ordered `visibleWhen` source query), read when the card builds an action\'s route. Dot paths are allowed (`@subject.owner.id`).',
+		members: ['@subject.<field>'],
+	},
 })
 
 /**

package/src/utils/userGroupsPeek.js

@@ -0,0 +1,87 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * The synchronous, reactive read of the current user's group ids, without
+ * the request that loads them.
+ *
+ * `resolveFilterTokens` (and through it `visibleWhen`) needs the groups for
+ * `@myGroups`, and those utilities are used on public, signed-out pages too.
+ * Importing `widgetVisibility.js` statically pulled `@nextcloud/axios` and
+ * `@nextcloud/router` into every bundle that resolves a filter token: a public
+ * site bundle broke its size budget, and node specs crashed because axios
+ * reads the request token when it is imported. This module imports no
+ * `@nextcloud/*` package. It loads `widgetVisibility.js` lazily, only the
+ * first time a signed-in user's groups are actually peeked.
+ *
+ * @module utils/userGroupsPeek
+ */
+
+import { reactive } from 'vue'
+
+/**
+ * Reactive mirror of the group cache, keyed by user id. A computed that reads
+ * a missing key tracks it, so it re-runs when the groups arrive.
+ *
+ * @type {{ byUser: Record<string, string[]> }}
+ */
+const _peek = reactive({ byUser: {} })
+
+/** User ids whose groups a peek already asked for (not reactive on purpose). */
+const _peekRequested = new Set()
+
+/**
+ * Get the current Nextcloud user ID from OC.currentUser.
+ *
+ * @return {string|null} The current user ID, or null if not logged in
+ */
+export function getCurrentUserId() {
+	return window.OC?.currentUser?.uid
+		|| window.OC?.currentUser
+		|| null
+}
+
+/**
+ * Synchronous, reactive read of the current user's group ids, for code that
+ * cannot await (the `@myGroups` filter token). Returns the ids once they are
+ * loaded, `null` while the first request is in flight (and starts that
+ * request on first use), and `[]` when nobody is signed in. Read inside a
+ * computed, the computed re-runs when the groups arrive.
+ *
+ * @spec openspec/changes/nextcloud-group-surfaces/specs/schema-utilities/spec.md#requirement-mygroups-resolves-to-the-current-users-group-ids
+ * @return {string[]|null} The group ids, or null while loading.
+ */
+export function peekCurrentUserGroups() {
+	const userId = getCurrentUserId()
+	if (!userId) {
+		return []
+	}
+	const known = _peek.byUser[userId]
+	if (Array.isArray(known)) {
+		return known
+	}
+	if (!_peekRequested.has(userId)) {
+		_peekRequested.add(userId)
+		import('./widgetVisibility.js')
+			.then((module) => module.getCurrentUserGroups())
+			.then((groups) => {
+				_peek.byUser[userId] = Array.isArray(groups) ? [...groups] : []
+			})
+			.catch(() => {
+				_peek.byUser[userId] = []
+			})
+	}
+	return null
+}
+
+/**
+ * Forget every peeked group list. `resetVisibilityCache()` calls this.
+ *
+ * @spec exclude test helper behind resetVisibilityCache, no behaviour of its own
+ */
+export function resetGroupsPeek() {
+	_peekRequested.clear()
+	for (const key of Object.keys(_peek.byUser)) {
+		delete _peek.byUser[key]
+	}
+}