@conduction/nextcloud-vue 2.75.0 → 2.77.0

package/src/utils/objectSignals.js

@@ -0,0 +1,41 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * Signal that objects changed outside the surface showing them, such as files
+ * uploaded or an object saved from an app's own modal. CnIndexPage listens and
+ * refreshes its list when the register and schema match.
+ *
+ * @module utils/objectSignals
+ */
+
+export const OBJECTS_CHANGED_EVENT = 'cn:objects-changed'
+
+/**
+ * Announce that objects of a register and schema changed.
+ *
+ * Pass the same register and schema identifiers (slug or id) the listing page
+ * uses. Leaving one out matches every page on that part.
+ *
+ * @param {object} [payload] What changed.
+ * @param {string|number} [payload.register] The register slug or id.
+ * @param {string|number} [payload.schema] The schema slug or id.
+ * @param {string} [payload.id] The changed object's id, when there is one.
+ * @return {boolean} True when the event was dispatched.
+ */
+export function dispatchObjectsChanged({ register, schema, id } = {}) {
+	if (typeof window === 'undefined') {
+		return false
+	}
+	const detail = {
+		register: register === undefined || register === null || register === '' ? null : String(register),
+		schema: schema === undefined || schema === null || schema === '' ? null : String(schema),
+		id: id ? String(id) : null,
+	}
+	try {
+		window.dispatchEvent(new CustomEvent(OBJECTS_CHANGED_EVENT, { detail }))
+		return true
+	} catch {
+		return false
+	}
+}

package/src/utils/personalLenses.js

@@ -2,30 +2,37 @@
  * SPDX-FileCopyrightText: 2026 Conduction B.V.
  * SPDX-License-Identifier: EUPL-1.2
  *
- * The personal lenses of an index page (Favourites, Recent, Following) as
- * quick filters, appended after the page's own.
+ * The personal lenses of an index page (Following, Recent, Unread) as quick
+ * filters, appended after the page's own.
  *
- * @spec openspec/changes/record-favourite-and-follow/tasks.md#task-3
+ * There is no Favourites lens any more: a favourite is a follow with
+ * notifications off (OpenRegister `merge-follow-and-favourites`), so
+ * `favourite` is an alias of `watching` and asking for both gives one tab.
+ *
+ * @spec openspec/changes/one-follow-control/specs/record-follow/spec.md#requirement-index-pages-offer-one-following-lens-and-a-follow-column
  */
 import { translate as t } from '@nextcloud/l10n'
 
 /** Lens id to the query key OpenRegister reads. */
-export const LENS_FILTER_KEYS = { favourite: '_favourite', recent: '_recent', watching: '_watching', unread: '_unread' }
+export const LENS_FILTER_KEYS = { recent: '_recent', watching: '_watching', unread: '_unread' }
+
+/** Deprecated lens ids and the lens they now mean. */
+const LENS_ALIASES = { favourite: 'watching' }
 
 /**
  * Quick filters for the requested lenses. Unknown ids are ignored.
  *
- * @param {string[]} lenses Any of `favourite`, `recent`, `watching`, `unread`.
+ * @param {string[]} lenses Any of `watching`, `recent`, `unread`, and the deprecated `favourite` (read as `watching`).
  * @return {Array<{label: string, filter: object, lens: string}>} One tab per lens, in the order asked.
  */
 export function personalLensTabs(lenses) {
 	const labels = {
-		favourite: t('nextcloud-vue', 'Favourites'),
 		recent: t('nextcloud-vue', 'Recent'),
 		watching: t('nextcloud-vue', 'Following'),
 		unread: t('nextcloud-vue', 'Unread'),
 	}
 	return (Array.isArray(lenses) ? lenses : [])
+		.map((id) => (Object.hasOwn(LENS_ALIASES, id) ? LENS_ALIASES[id] : id))
 		.filter((id, i, all) => Object.hasOwn(LENS_FILTER_KEYS, id) && all.indexOf(id) === i)
 		.map((id) => ({ label: labels[id], filter: { [LENS_FILTER_KEYS[id]]: true }, lens: id }))
 }

package/src/utils/recordInteractions.js

@@ -2,8 +2,10 @@
  * SPDX-FileCopyrightText: 2026 Conduction B.V.
  * SPDX-License-Identifier: EUPL-1.2
  *
- * The per-user interaction calls OpenRegister serves on a record: favourite,
- * watch (follow) and the watchers list. Plain functions over `fetch`, shared
+ * The per-user interaction calls OpenRegister serves on a record: follow
+ * (watch, with its notifications switch), the watchers list, the read state,
+ * and the deprecated favourite (a quiet follow since OpenRegister's
+ * `merge-follow-and-favourites`). Plain functions over `fetch`, shared
  * by the interactions store plugin and by the toggles, so a toggle works with
  * or without the plugin installed.
  *
@@ -31,13 +33,18 @@ export function interactionUrl(register, schema, id, tail) {
 /**
  * Send one interaction call and normalise the answer. Never throws.
  *
- * @param {string} method HTTP method.
- * @param {string} url    Full URL.
+ * @param {string}      method HTTP method.
+ * @param {string}      url    Full URL.
+ * @param {object|null} [body] JSON body, or null for none.
  * @return {Promise<{ok: boolean, status: number|null, data: (object|null), message: string}>} The outcome; `message` is the server's, or a network message.
  */
-async function call(method, url) {
+async function call(method, url, body = null) {
 	try {
-		const response = await fetch(prefixUrl(url), { method, headers: buildHeaders() })
+		const init = { method, headers: buildHeaders() }
+		if (body !== null) {
+			init.body = JSON.stringify(body)
+		}
+		const response = await fetch(prefixUrl(url), init)
 		if (!response.ok) {
 			const error = await parseResponseError(response, 'record')
 			// The server's own words win over the generic status text.
@@ -61,6 +68,9 @@ async function call(method, url) {
 /**
  * Star or unstar a record for the current user.
  *
+ * @deprecated A star is a quiet follow since OpenRegister's
+ * `merge-follow-and-favourites`; use `setWatching(..., { notify: false })`.
+ *
  * @param {string}  register Register slug.
  * @param {string}  schema   Schema slug.
  * @param {string}  id       Object id.
@@ -72,16 +82,24 @@ export function setFavourite(register, schema, id, on) {
 }
 
 /**
- * Follow or unfollow a record for the current user.
+ * Follow or unfollow a record for the current user, optionally setting the
+ * follow's notifications switch.
  *
- * @param {string}  register Register slug.
- * @param {string}  schema   Schema slug.
- * @param {string}  id       Object id.
- * @param {boolean} on       True to follow, false to unfollow.
+ * `options.notify` is sent only when following and only when it is a boolean:
+ * left out, a new follow notifies and an existing follow keeps its setting.
+ *
+ * @param {string}  register         Register slug.
+ * @param {string}  schema           Schema slug.
+ * @param {string}  id               Object id.
+ * @param {boolean} on               True to follow, false to unfollow.
+ * @param {object}  [options]        Options.
+ * @param {boolean} [options.notify] The notifications switch.
  * @return {Promise<object>} The outcome (see `call`).
+ * @spec openspec/changes/one-follow-control/specs/record-follow/spec.md#requirement-one-follow-control-with-a-notifications-switch
  */
-export function setWatching(register, schema, id, on) {
-	return call(on ? 'PUT' : 'DELETE', interactionUrl(register, schema, id, 'watch'))
+export function setWatching(register, schema, id, on, options = {}) {
+	const body = on && options && typeof options.notify === 'boolean' ? { notify: options.notify } : null
+	return call(on ? 'PUT' : 'DELETE', interactionUrl(register, schema, id, 'watch'), body)
 }
 
 /**

package/src/utils/resolveFilterTokens.js

@@ -10,6 +10,13 @@
  * Supported tokens:
  *  - `@me`                → the current Nextcloud user id (`getCurrentUser()` from
  *                           `@nextcloud/auth`; `window.OC.currentUser` fallback)
+ *  - `@myGroups`          → the ids of the Nextcloud groups the current user is
+ *                           in, as an ARRAY (an IN filter). `ctx.myGroups` wins;
+ *                           otherwise a reactive peek over `getCurrentUserGroups`.
+ *                           Stays UNRESOLVED while loading and when the user is
+ *                           in no group, so the caller waits instead of sending
+ *                           an empty IN list (which OpenRegister reads as "no
+ *                           constraint"). Spread in place inside an IN-list array.
  *  - `@now`               → the current instant, ISO-8601
  *  - `@today`             → today at 00:00, `YYYY-MM-DD` (date-prefix comparable)
  *  - `@today±Nd`          → relative-date arithmetic at day granularity: N days
@@ -56,6 +63,34 @@
 
 import { getCurrentUser } from '@nextcloud/auth'
 import { TODAY_DELTA_RE } from './sentinelTokens.js'
+import { peekCurrentUserGroups } from './widgetVisibility.js'
+
+/** The filter token for the current user's group ids. */
+export const MY_GROUPS_TOKEN = '@myGroups'
+
+/**
+ * Resolve `@myGroups`: the current user's group ids, or the token itself while
+ * they are loading or when there are none (an empty IN list would match every
+ * row, so "no team" must mean "wait", never "everything").
+ *
+ * @spec openspec/changes/nextcloud-group-surfaces/specs/schema-utilities/spec.md#requirement-mygroups-resolves-to-the-current-users-group-ids
+ * @param {{myGroups?: string[]}} [ctx] Optional context; `ctx.myGroups` wins.
+ * @return {string[]|string} The group ids, or `'@myGroups'` when unresolved.
+ */
+function resolveMyGroups(ctx) {
+	let groups = ctx && Array.isArray(ctx.myGroups) ? ctx.myGroups : null
+	if (groups === null) {
+		try {
+			groups = peekCurrentUserGroups()
+		} catch {
+			groups = null
+		}
+	}
+	const ids = Array.isArray(groups)
+		? groups.filter((g) => typeof g === 'string' && g !== '')
+		: []
+	return ids.length > 0 ? [...ids] : MY_GROUPS_TOKEN
+}
 
 /**
  * Format a Date as `YYYY-MM-DD` (local).
@@ -73,7 +108,7 @@ function ymd(d) {
  * Resolve a single filter value if it is a dynamic `@`-token, else pass through.
  *
  * @param {unknown} v The candidate value.
- * @param {{objectId?: (string|number), object?: object, workspace?: object, config?: object, range?: object}} [ctx] Optional
+ * @param {{objectId?: (string|number), object?: object, workspace?: object, config?: object, range?: object, myGroups?: string[]}} [ctx] Optional
  *   context for `@objectId` / `@object.<field>` (detail page),
  *   `@workspace.<key>` (page-level workspace state), and `@config.<key>`
  *   (page-level app config) tokens.
@@ -84,6 +119,9 @@ export function resolveFilterValue(v, ctx) {
 		return v
 	}
 	const now = new Date()
+	if (v === MY_GROUPS_TOKEN) {
+		return resolveMyGroups(ctx)
+	}
 	if (v === '@objectId') {
 		return (ctx && ctx.objectId !== undefined && ctx.objectId !== null) ? String(ctx.objectId) : v
 	}
@@ -313,8 +351,13 @@ export function resolveFilterTokens(filter, ctx) {
 	if (!filter || typeof filter !== 'object') {
 		return filter
 	}
+	// An item that resolves to a list (`@myGroups`) is spread in place, so
+	// `['@myGroups', 'archive']` stays one flat IN list.
 	const resolveOne = (v) => (Array.isArray(v)
-		? v.map((item) => resolveFilterValue(item, ctx))
+		? v.flatMap((item) => {
+				const r = resolveFilterValue(item, ctx)
+				return Array.isArray(r) ? r : [r]
+			})
 		: resolveFilterValue(v, ctx))
 	const out = {}
 	for (const [k, v] of Object.entries(filter)) {

package/src/utils/schema.js

@@ -385,7 +385,7 @@ function isUserProp(prop) {
  * @param {object} prop A schema property definition (or `items` for an array).
  * @return {boolean} True when the property marks a Nextcloud group.
  */
-function isGroupProp(prop) {
+export function isGroupProp(prop) {
 	if (!prop || typeof prop !== 'object') {
 		return false
 	}

package/src/utils/sentinelTokens.js

@@ -26,7 +26,7 @@
  * A token is valid only in the context whose resolver runs on it:
  *
  *  - **filter**       — `resolveFilterTokens`, resolved at fetch time:
- *                       `@me`, `@now`, `@today`, `@today±Nd`, `@monthStart`,
+ *                       `@me`, `@myGroups`, `@now`, `@today`, `@today±Nd`, `@monthStart`,
  *                       `@quarterStart`, `@yearStart`.
  *  - **config**       — `IAppConfig`-sourced: `@resolve:<key>`, `@config.<key>`
  *                       (trailing `?` marks optional).
@@ -67,7 +67,7 @@
  * @type {Readonly<Record<string, string>>}
  */
 export const SENTINEL_TOKEN_PATTERNS = Object.freeze({
-	filter: '^@(?:me(?:\\.(?:displayName|email))?|now|today|monthStart|quarterStart|yearStart)$|^@today[+-][0-9]+d$',
+	filter: '^@(?:me(?:\\.(?:displayName|email))?|myGroups|now|today|monthStart|quarterStart|yearStart)$|^@today[+-][0-9]+d$',
 	config: '^@resolve:[a-z][a-z0-9_-]*$|^@config\\.[A-Za-z][A-Za-z0-9_.]*\\??$',
 	object: '^@objectId$|^@object\\.[A-Za-z][A-Za-z0-9_]*$',
 	workspace: '^@workspace\\.[A-Za-z][A-Za-z0-9_]*\\??$',
@@ -116,8 +116,8 @@ export const SENTINEL_CONTEXTS = Object.freeze([
 export const SENTINEL_VOCABULARY = Object.freeze({
 	filter: {
 		resolver: 'resolveFilterTokens',
-		description: 'Relative fetch-time tokens (current user / relative dates).',
-		members: ['@me', '@me.displayName', '@me.email', '@now', '@today', '@today±Nd', '@monthStart', '@quarterStart', '@yearStart'],
+		description: 'Relative fetch-time tokens (current user, the current user\'s groups as an IN list, relative dates).',
+		members: ['@me', '@me.displayName', '@me.email', '@myGroups', '@now', '@today', '@today±Nd', '@monthStart', '@quarterStart', '@yearStart'],
 	},
 	config: {
 		resolver: 'resolveManifestSentinels / resolveFilterTokens',