@conduction/nextcloud-vue 2.70.0 → 2.71.0

package/src/composables/useWalkthrough.js

@@ -216,11 +216,13 @@ export function walkthroughProgressKey(configKey) {
 
 /**
  * Normalise stored progress (an object, or the JSON string a preference
- * holds) into `{ tourId, stepId, index, version }`, or null.
+ * holds) into `{ tourId, stepId, index, version }`, plus `paused: true`
+ * when the user paused the tour, or null.
  *
  * @spec openspec/changes/walkthrough-advance-pause-resume/specs/cn-walkthrough/spec.md
+ * @spec openspec/changes/audit-round-lib-fixes/specs/cn-walkthrough/spec.md
  * @param {unknown} value The stored value.
- * @return {{tourId: string, stepId: string, index: number, version: string}|null} The progress.
+ * @return {{tourId: string, stepId: string, index: number, version: string, paused: (boolean|undefined)}|null} The progress.
  */
 export function normaliseWalkthroughProgress(value) {
 	let data = value
@@ -237,12 +239,18 @@ export function normaliseWalkthroughProgress(value) {
 	if (!isPlainObject(data) || typeof data.tourId !== 'string' || data.tourId === '') {
 		return null
 	}
-	return {
+	const progress = {
 		tourId: data.tourId,
 		stepId: typeof data.stepId === 'string' ? data.stepId : '',
 		index: Number.isInteger(data.index) && data.index >= 0 ? data.index : 0,
 		version: typeof data.version === 'string' ? data.version : '',
 	}
+	// A paused tour stays hidden on the next visit until the user picks
+	// "Continue". Only written when true, so older values read unchanged.
+	if (data.paused === true) {
+		progress.paused = true
+	}
+	return progress
 }
 
 /**

package/src/css/dashboard.css

@@ -129,3 +129,47 @@
 .cn-requires-app.cn-requires-app .empty-content__action {
 	margin-top: var(--default-grid-baseline, 4px);
 }
+
+/* NcEmptyContent forces its icon's svg to 64px with !important while the
+ * rule above lets the icon box shrink, so the svg spilled out of its box and
+ * over the name. Hold the svg to the size the caller asked for. */
+.cn-requires-app.cn-requires-app .empty-content__icon svg {
+	width: 32px !important;
+	height: 32px !important;
+	max-width: 32px !important;
+	max-height: 32px !important;
+}
+
+/* The dashboard's compact "Install <app>" placeholder: two lines of text and
+ * the button, nothing else, so it fits a two-row tile even under a title row.
+ * `safe center` keeps the top in view when a tile is smaller still, and the
+ * body scrolls rather than clipping the button. */
+.cn-requires-app--compact {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	justify-content: safe center;
+	gap: calc(2 * var(--default-grid-baseline, 4px));
+	box-sizing: border-box;
+	height: 100%;
+	min-height: 0;
+	overflow: auto;
+	padding: calc(2 * var(--default-grid-baseline, 4px));
+	text-align: center;
+}
+
+.cn-requires-app--compact .cn-requires-app__description {
+	display: -webkit-box;
+	margin: 0;
+	overflow: hidden;
+	color: var(--color-text-maxcontrast);
+	font-size: 0.9em;
+	line-height: 1.4;
+	-webkit-box-orient: vertical;
+	-webkit-line-clamp: 2;
+	line-clamp: 2;
+}
+
+.cn-requires-app--compact .button-vue {
+	flex-shrink: 0;
+}

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.52.0",
+	"version": "2.53.0",
 	"type": "object",
 	"required": ["$schema", "version"],
 	"allOf": [
@@ -64,6 +64,7 @@
 				"enabled": { "type": "boolean", "default": true, "description": "Whether the setup wizard is active for this app." },
 				"version": { "type": "integer", "default": 1, "description": "Setup contract version; bump to re-trigger setup after a breaking change." },
 				"completionConfigKey": { "type": "string", "description": "App-config key storing the completed setup version." },
+				"dismissAction": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$", "description": "Setup action that records a closed or finished setup wizard on the server, so it stays closed in every browser. CnAppRoot posts `/apps/{appId}/api/setup/action/{dismissAction}` with `{ finished }` once when the user closes or finishes the wizard. The app either answers the outstanding optional steps or reports `dismissed` (true, or the setup version it was closed at) in `GET /api/setup/status`. Without it, the close is remembered only in the browser (localStorage), as before." },
 				"steps": {
 					"type": "array",
 					"description": "Ordered setup steps rendered by CnSetupWizard.",

package/src/utils/columnFilters.js

@@ -161,15 +161,65 @@ function referenceTarget(column, prop) {
 	return { schema, register, labelField }
 }
 
+/**
+ * Whether a schema lists its properties. Without that the table knows its
+ * columns but not what backs them.
+ *
+ * @param {object|null} schema The table's schema.
+ * @return {boolean} True when the schema has a properties map.
+ */
+function hasProperties(schema) {
+	return !!(schema && typeof schema === 'object' && schema.properties && typeof schema.properties === 'object')
+}
+
+/**
+ * A filter for a column when the table has no schema to read (a manifest
+ * page whose schema did not resolve, a host-fed table). The column's own
+ * hints decide the kind: an `fkResolve` widget gives a reference filter, a
+ * `type` or `format` on the column gives number, date or yes/no, and every
+ * other plain stored key gets a text filter on contains (`[like]`). A key
+ * that is a path (`a.b`) or a metadata field (`@self`, `_id`) gets none,
+ * because OpenRegister does not filter those by that name.
+ *
+ * @spec openspec/changes/audit-round-lib-fixes/specs/cn-data-table/spec.md
+ * @param {object} column The column definition.
+ * @param {object} base The shared part of the definition.
+ * @return {object|null} The filter definition.
+ */
+function columnHintFilterDef(column, base) {
+	const key = column.key
+	if (key.includes('.') || key.charAt(0) === '@' || key.charAt(0) === '_') {
+		return null
+	}
+	const reference = referenceTarget(column, null)
+	if (reference) {
+		return { ...base, kind: 'reference', reference }
+	}
+	const type = String(column.type || '').toLowerCase()
+	const format = String(column.format || '').toLowerCase()
+	if (type === 'boolean') {
+		return { ...base, kind: 'boolean' }
+	}
+	if (type === 'number' || type === 'integer') {
+		return { ...base, kind: 'number' }
+	}
+	if (type === 'date' || type === 'date-time' || format === 'date' || format === 'date-time') {
+		return { ...base, kind: 'date', dateTime: type === 'date-time' || format === 'date-time' }
+	}
+	return { ...base, kind: 'string' }
+}
+
 /**
  * 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` (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.
+ * off. When the schema lists its properties, a column with no 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. When there is no schema to read, the column's own hints decide
+ * (see `columnHintFilterDef`), falling back to a text filter on contains.
  *
  * @param {object} column The column definition.
  * @param {object|null} schema The table's schema.
@@ -191,7 +241,7 @@ export function columnFilterDef(column, schema) {
 		return { ...base, kind: 'enum', options }
 	}
 	if (!prop) {
-		return null
+		return hasProperties(schema) ? null : columnHintFilterDef(column, base)
 	}
 	const reference = referenceTarget(column, prop)
 	if (reference) {

package/src/utils/userAutocomplete.js

@@ -12,9 +12,50 @@
  * @module utils/userAutocomplete
  */
 
+import { getCurrentUser } from '@nextcloud/auth'
 import axios from '@nextcloud/axios'
 import { generateOcsUrl } from '@nextcloud/router'
 
+/**
+ * The signed-in user as a picker option, or null when nobody is signed in.
+ *
+ * Core autocomplete never returns the person who searches (it is built for
+ * sharing, and you do not share with yourself), so a picker backed by it
+ * alone cannot assign a task to yourself.
+ *
+ * @spec openspec/changes/audit-round-lib-fixes/specs/schema-utilities/spec.md
+ * @return {{id: string, label: string, displayName: string, subline: string}|null} The option.
+ */
+function currentUserOption() {
+	let user
+	try {
+		user = getCurrentUser()
+	} catch {
+		return null
+	}
+	if (!user || !user.uid) {
+		return null
+	}
+	const name = user.displayName || String(user.uid)
+	return { id: String(user.uid), label: name, displayName: name, subline: '' }
+}
+
+/**
+ * Whether the current-user option matches a search term (uid or display
+ * name contains the term, ignoring case). An empty term matches.
+ *
+ * @param {object} option The current-user option.
+ * @param {string} query The search term.
+ * @return {boolean} True when it matches.
+ */
+function matchesQuery(option, query) {
+	const q = String(query || '').trim().toLowerCase()
+	if (q === '') {
+		return true
+	}
+	return option.id.toLowerCase().includes(q) || option.label.toLowerCase().includes(q)
+}
+
 /**
  * Map one autocomplete suggestion to a picker option, keeping only user
  * results. The OCS payload uses `id` for the UID, `label` for the display
@@ -59,10 +100,11 @@ function toUserOption(suggestion) {
  * @param {string} [query] The search term (empty loads an initial page).
  * @param {object} [options] Tuning options.
  * @param {number} [options.limit] Max results (default 25).
+ * @param {boolean} [options.includeCurrentUser] Add the signed-in user when they match (default true; a mention list passes false).
  * @return {Promise<Array<{id: string, label: string, subline: string}>>} Picker options.
  */
 export async function searchNextcloudUsers(query = '', options = {}) {
-	const { limit = 25 } = options
+	const { limit = 25, includeCurrentUser = true } = options
 	try {
 		const url = generateOcsUrl('core/autocomplete/get')
 		const response = await axios.get(url, {
@@ -86,14 +128,32 @@ export async function searchNextcloudUsers(query = '', options = {}) {
 		const list = Array.isArray(data)
 			? data
 			: (Array.isArray(response && response.data) ? response.data : [])
-		return list
+		const found = list
 			.map(toUserOption)
 			.filter((opt) => opt !== null)
+		return includeCurrentUser ? withCurrentUser(found, query) : found
 	} catch {
 		return []
 	}
 }
 
+/**
+ * Put the signed-in user first in a result list when they match the search
+ * and the server left them out.
+ *
+ * @spec openspec/changes/audit-round-lib-fixes/specs/schema-utilities/spec.md
+ * @param {Array<object>} options The server's options.
+ * @param {string} query The search term.
+ * @return {Array<object>} The options, the current user included when they match.
+ */
+function withCurrentUser(options, query) {
+	const me = currentUserOption()
+	if (!me || !matchesQuery(me, query) || options.some((opt) => opt.id === me.id)) {
+		return options
+	}
+	return [me, ...options]
+}
+
 /**
  * Resolve a single user UID to a `{ id, label }` option for edit-mode display.
  * Tries the autocomplete endpoint with the UID as the query and matches the
@@ -108,6 +168,12 @@ export async function resolveNextcloudUser(uid) {
 	if (uid === undefined || uid === null || uid === '') {
 		return fallback
 	}
+	// The server never returns the signed-in user, so their own uid would
+	// otherwise fall back to the bare uid.
+	const me = currentUserOption()
+	if (me && me.id === String(uid)) {
+		return me
+	}
 	const results = await searchNextcloudUsers(String(uid))
 	const match = results.find((opt) => opt.id === String(uid))
 	return match || fallback