@conduction/nextcloud-vue 2.65.0 → 2.67.0

package/src/components/CnSetupWizard/CnSetupWizard.vue

@@ -199,13 +199,12 @@
 
 <script>
 import { getCurrentUser } from '@nextcloud/auth'
-import { loadState } from '@nextcloud/initial-state'
 import { translate as t } from '@nextcloud/l10n'
 import { NcButton, NcCheckboxRadioSwitch, NcLoadingIcon, NcNoteCard, NcSelect, NcTextField } from '@nextcloud/vue'
 import CnChoiceCards from '../CnChoiceCards/CnChoiceCards.vue'
 import CnLeafDependencySettings from '../CnLeafDependencySettings/CnLeafDependencySettings.vue'
 import CnWizardDialog from '../CnWizardDialog/CnWizardDialog.vue'
-import { checkDependencies, isDependencyResolved } from '../../composables/useDependencyCheck.js'
+import { checkDependencies, isDependencyResolved, missingRequiredApps, readServerAppStatuses } from '../../composables/useDependencyCheck.js'
 import { useSetupStatus } from '../../composables/useSetupStatus.js'
 import { fieldsFromSchema } from '../../utils/schema.js'
 
@@ -474,16 +473,15 @@ export default {
 		 *
 		 * @return {Array<{ step: object, missing: Array<string> }>}
 		 * @spec openspec/changes/setup-wizard-card-load-and-dependency-gate/specs/cn-setup-wizard/spec.md#requirement-the-wizard-checks-dependencies-before-any-step
+		 * @spec openspec/changes/optional-step-requires/specs/cn-setup-wizard/spec.md#requirement-a-step-whose-required-apps-are-absent-is-not-applicable
 		 */
 		skippedSteps() {
 			return this.declaredSteps
 				.filter((s) => Array.isArray(s.requires) && s.requires.length > 0)
 				.map((step) => {
 					const known = Object.fromEntries(this.dependencyRows.map((d) => [d.id, d]))
-					const missing = checkDependencies(step.requires, this.serverAppStatuses)
-						.map((row) => known[row.id] || row)
-						.filter((row) => !isDependencyResolved(row))
-						.map((row) => row.name || row.id)
+					const missing = missingRequiredApps(step.requires, this.serverAppStatuses)
+						.map((row) => (known[row.id] || row).name || row.id)
 					return { step, missing }
 				})
 				.filter((entry) => entry.missing.length > 0)
@@ -523,11 +521,7 @@ export default {
 		 * @return {object}
 		 */
 		serverAppStatuses() {
-			try {
-				return loadState(this.appId, 'dependency_statuses', {}) || {}
-			} catch {
-				return {}
-			}
+			return readServerAppStatuses(this.appId)
 		},
 
 		/**

package/src/composables/useDependencyCheck.js

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: EUPL-1.2
  */
 
+import { loadState } from '@nextcloud/initial-state'
 import { useAppStatus } from './useAppStatus.js'
 
 /**
@@ -59,3 +60,45 @@ export function checkDependencies(entries, serverStatuses = {}) {
 export function isDependencyResolved(row) {
 	return !!row && row.installed === true && row.enabled === true
 }
+
+/**
+ * Read the `dependency_statuses` initial state an app may inject from PHP.
+ *
+ * Keyed by app id: `{ installed, enabled }`. Returns `{}` when the app injects
+ * none or the state cannot be read, so callers fall back to `useAppStatus`.
+ *
+ * @param {string} appId The app whose initial state to read.
+ * @return {object} Server-reported statuses keyed by app id.
+ *
+ * @spec openspec/changes/optional-step-requires/specs/cn-setup-wizard/spec.md#requirement-a-step-whose-required-apps-are-absent-is-not-applicable
+ */
+export function readServerAppStatuses(appId) {
+	try {
+		const statuses = loadState(appId, 'dependency_statuses', {})
+		return (statuses && typeof statuses === 'object') ? statuses : {}
+	} catch {
+		return {}
+	}
+}
+
+/**
+ * The apps in a setup step's `requires` list that are not installed and
+ * enabled.
+ *
+ * This is the one resolution every setup surface uses: `CnSetupWizard` skips a
+ * step when it is non-empty, and `useSetupStatus` then counts that step as not
+ * applicable rather than unmet. Keeping both on one function is what stops the
+ * wizard and the status from disagreeing about the same step.
+ *
+ * @param {Array<string>} requires The step's `requires` app ids.
+ * @param {object} [serverStatuses] Server-reported statuses keyed by app id.
+ * @return {Array<{id: string, name: string, required: boolean, installed: boolean, enabled: boolean}>} The missing apps.
+ *
+ * @spec openspec/changes/optional-step-requires/specs/cn-setup-wizard/spec.md#requirement-a-step-whose-required-apps-are-absent-is-not-applicable
+ */
+export function missingRequiredApps(requires, serverStatuses = {}) {
+	if (!Array.isArray(requires) || requires.length === 0) {
+		return []
+	}
+	return checkDependencies(requires, serverStatuses).filter((row) => !isDependencyResolved(row))
+}

package/src/composables/useListView.js

@@ -94,6 +94,13 @@ export function useListView(objectTypeOrOptions, options) {
 	// field (a folder pane grouping by it, say) reads them here rather than
 	// deriving them from `objects`, which is only the current page.
 	const facets = computed(() => objectStore.facets[objectType] || {})
+	// Outcome of the latest `refresh()`: the store's error for it, or null once
+	// it succeeded or a later fetch stored new rows. The store keeps the previous
+	// rows on a failed fetch, so this is how a consumer tells stale rows from
+	// current ones.
+	const error = ref(null)
+	let refreshSeq = 0
+	let pendingRefreshes = 0
 
 	let searchTimeout = null
 
@@ -178,14 +185,48 @@ export function useListView(objectTypeOrOptions, options) {
 
 	/**
 	 * Fetch the collection using current state params and update sidebar facet data.
+	 * Only the most recently started refresh sets `error`, so an older response
+	 * settling late cannot override a newer one's outcome.
 	 *
 	 * @param {number} [page] Page to fetch
 	 * @return {Promise<void>}
 	 */
 	async function refresh(page = 1) {
-		await objectStore.fetchCollection(objectType, buildParams(page))
+		const seq = ++refreshSeq
+		// This call's own result. `errors[objectType]` is shared by every call
+		// for the type and is not cleared on success, so it cannot say which
+		// request failed; it is only the fallback for a store that ignores
+		// `options.outcome`.
+		const outcome = {}
+		pendingRefreshes++
+		try {
+			await objectStore.fetchCollection(objectType, buildParams(page), { outcome })
+		} catch (e) {
+			if (seq === refreshSeq) {
+				error.value = e
+			}
+			throw e
+		} finally {
+			pendingRefreshes--
+		}
+		if (seq === refreshSeq) {
+			error.value = ('error' in outcome) ? outcome.error : (objectStore.errors?.[objectType] || null)
+		}
 	}
 
+	// A fetch outside `refresh()` (e.g. the live-updates refetch) that stores
+	// new rows recovers the list from an earlier failure. Rows written while
+	// a refresh is pending are left to that refresh, which decides `error`.
+	watch(
+		() => objectStore.collections[objectType],
+		() => {
+			if (pendingRefreshes === 0) {
+				error.value = null
+			}
+		},
+		{ flush: 'sync' },
+	)
+
 	// ── Event handlers ───────────────────────────────────────────────────
 
 	/**
@@ -323,6 +364,7 @@ export function useListView(objectTypeOrOptions, options) {
 		loading,
 		pagination,
 		facets,
+		error,
 		// Local state
 		searchTerm,
 		sortKey,

package/src/composables/useSetupStatus.js

@@ -4,6 +4,7 @@
  */
 
 import { computed, ref } from 'vue'
+import { missingRequiredApps, readServerAppStatuses } from './useDependencyCheck.js'
 
 /**
  * Per-`appId` cache of setup-status results. The Vue refs are stored so all
@@ -27,6 +28,14 @@ const cache = new Map()
  * every non-admin user of an app with a `setup` block met a wizard they had no
  * permission to complete instead of the app itself.
  *
+ * A step that declares `requires: [appId, ...]` is **not applicable** while any
+ * of those apps is not installed and enabled: it is neither met nor unmet, so
+ * it never lands in `requiredUnmet` or `optionalUnmet`. `CnSetupWizard` skips
+ * such a step, and counting it as unmet kept the wizard reopening (optional
+ * step) or gating the app (required step) for a step it would never show. App
+ * status is resolved exactly as the wizard does it: the `dependency_statuses`
+ * initial state first, then `useAppStatus`.
+ *
  * @param {string} appId Nextcloud app id (e.g. `"procest"`).
  * @param {object} manifest The app manifest (reads `manifest.setup`).
  * @return {{
@@ -35,6 +44,7 @@ const cache = new Map()
  *   requiredUnmet: import('vue').ComputedRef<Array<object>>,
  *   optionalUnmet: import('vue').ComputedRef<Array<object>>,
  *   optionalUnmetReported: import('vue').ComputedRef<Array<object>>,
+ *   notApplicable: import('vue').ComputedRef<Array<object>>,
  *   completed: import('vue').ComputedRef<boolean>,
  *   enabled: boolean,
  *   loading: import('vue').Ref<boolean>,
@@ -45,6 +55,7 @@ const cache = new Map()
  *
  * @example
  * const { requiredUnmet, completed, loading } = useSetupStatus('procest', manifest)
+ * @spec openspec/changes/optional-step-requires/specs/cn-setup-wizard/spec.md#requirement-a-step-whose-required-apps-are-absent-is-not-applicable
  */
 export function useSetupStatus(appId, manifest) {
 	const setup = (manifest && manifest.setup) || {}
@@ -68,6 +79,9 @@ export function useSetupStatus(appId, manifest) {
 		cache.set(appId, entry)
 	}
 	const { status, loading, error, forbidden } = entry
+	// Same source the wizard's dependency gate reads. Initial state is fixed
+	// for the page lifetime, so one read per call is enough.
+	const serverAppStatuses = readServerAppStatuses(appId)
 
 	const steps = computed(() => stepDefs.map((s) => {
 		const bag = status.value.steps || {}
@@ -81,7 +95,12 @@ export function useSetupStatus(appId, manifest) {
 		// that act on an unmet step — CnAppRoot auto-opening the non-gating
 		// wizard — must act only on steps the server actually reported, or an
 		// unknowable step parks the wizard over the app for ever.
-		return { ...s, done: st.done === true, reported, detail: st.detail }
+		//
+		// `applicable` is false when the step `requires` an app that is not
+		// installed and enabled. The wizard skips such a step, so it can never
+		// be done here; it is not applicable rather than unmet.
+		const missingApps = missingRequiredApps(s.requires, serverAppStatuses).map((row) => row.id)
+		return { ...s, done: st.done === true, reported, detail: st.detail, applicable: missingApps.length === 0, missingApps }
 	}))
 	// Presentational step types carry no work, so the server never reports a
 	// `done` flag for them. Counting them as "unmet" made `optionalUnmet`
@@ -89,7 +108,9 @@ export function useSetupStatus(appId, manifest) {
 	// which kept CnAppRoot's non-gating setup wizard auto-opening over the
 	// app on every fresh browser profile no matter how complete setup was.
 	// Only actionable steps can be unmet.
-	const isActionable = (s) => s.type !== 'info' && s.type !== 'summary'
+	// A step whose required apps are absent is skipped by the wizard, so it
+	// is neither met nor unmet (see `applicable` above).
+	const isActionable = (s) => s.type !== 'info' && s.type !== 'summary' && s.applicable !== false
 	// `forbidden` empties BOTH lists, and that is what actually suppresses the
 	// wizard: CnAppRoot gates on `requiredUnmet.length > 0` (blocking) and on
 	// `requiredUnmet.length === 0 && optionalUnmet.length > 0` (auto-open) —
@@ -110,6 +131,8 @@ export function useSetupStatus(appId, manifest) {
 	// suppressing it is what left dossiq's `seed` step (and with it the app's
 	// only demo-data affordance) permanently unreachable.
 	const optionalUnmetReported = computed(() => optionalUnmet.value.filter((s) => s.reported === true))
+	// Steps the wizard skips because an app in their `requires` is absent.
+	const notApplicable = computed(() => steps.value.filter((s) => s.applicable === false))
 	const completed = computed(() => {
 		if (!enabled) {
 			return true
@@ -170,7 +193,7 @@ export function useSetupStatus(appId, manifest) {
 		refresh()
 	}
 
-	return { steps, status, requiredUnmet, optionalUnmet, optionalUnmetReported, completed, enabled, loading, error, forbidden, refresh }
+	return { steps, status, requiredUnmet, optionalUnmet, optionalUnmetReported, notApplicable, completed, enabled, loading, error, forbidden, refresh }
 }
 
 /**

package/src/css/actions-bar.css

@@ -35,6 +35,23 @@
 	color: var(--color-text-maxcontrast);
 }
 
+/* Beside the inline search (`showCountWithSearch`): the search field shrinks
+   first and the counter stays on one line. */
+.cn-actions-bar__count--beside-search {
+	flex-shrink: 0;
+	white-space: nowrap;
+}
+
+/* Taken out of the flex row so it adds no gap, but kept in the accessibility
+   tree so the live region exists before a total appears. */
+.cn-actions-bar__count--empty {
+	position: absolute;
+	width: 1px;
+	height: 1px;
+	overflow: hidden;
+	clip-path: inset(50%);
+}
+
 /* Inline search field */
 .cn-actions-bar__search {
 	position: relative;
@@ -294,8 +311,9 @@
 		display: contents;
 	}
 
-	/* #after-search filter buttons + the view toggle ride beside the
-	   search field (DOM order — search first via its own order). */
+	/* #after-search filter buttons, the beside-search counter and the view
+	   toggle ride beside the search field (DOM order — search first via its
+	   own order). */
 	.cn-actions-bar__info > * {
 		order: 1;
 	}

package/src/css/detail-page.css

@@ -481,3 +481,8 @@
 	font-size: 0.9em;
 	white-space: nowrap;
 }
+
+/* A page view the switch shows with nothing to draw (view-switch-containers). */
+.cn-detail-page .cn-page-view-region--empty {
+	padding: 40px 20px;
+}