@conduction/nextcloud-vue 2.62.0 → 2.64.0

package/dist/esm/components/CnSetupWizard/CnSetupWizard.vue2.js

@@ -1,10 +1,20 @@
+import { getCurrentUser } from '@nextcloud/auth';
+import { loadState } from '@nextcloud/initial-state';
 import { translate } from '@nextcloud/l10n';
 import { NcButton, NcNoteCard, NcSelect, NcTextField, NcCheckboxRadioSwitch, NcLoadingIcon } from '@nextcloud/vue';
 import __sfc_main$1 from '../CnChoiceCards/CnChoiceCards.vue.js';
+import __sfc_main$2 from '../CnLeafDependencySettings/CnLeafDependencySettings.vue.js';
 import __sfc_main from '../CnWizardDialog/CnWizardDialog.vue.js';
+import { checkDependencies, isDependencyResolved } from '../../composables/useDependencyCheck.js';
 import { useSetupStatus } from '../../composables/useSetupStatus.js';
 import { fieldsFromSchema } from '../../utils/schema.js';
 
+/** Id of the synthetic step shown while a required app is missing. */
+const DEPENDENCY_STEP_ID = 'cn-setup-dependencies';
+
+/** The dataset value that means "seed nothing"; it never gets a Load button. */
+const NONE_DATASET = 'none';
+
 /**
  * CnSetupWizard — abstract, manifest-driven first-time setup wizard (ADR-042).
  *
@@ -34,6 +44,7 @@ var script = {
 	components: {
 		CnWizardDialog: __sfc_main,
 		CnChoiceCards: __sfc_main$1,
+		CnLeafDependencySettings: __sfc_main$2,
 		NcButton,
 		NcNoteCard,
 		NcSelect,
@@ -52,6 +63,11 @@ var script = {
 		 * standalone (no CnAppRoot ancestor).
 		 */
 		cnTranslate: { default: () => (key) => key },
+		/**
+		 * The app manifest, provided by CnAppRoot. Read only for its
+		 * `dependencies` when the `dependencies` prop is empty.
+		 */
+		cnManifest: { default: null },
 	},
 
 	props: {
@@ -161,6 +177,33 @@ var script = {
 			type: Array,
 			default: () => [],
 		},
+
+		/**
+		 * The app's dependencies, in the manifest's own shape (app-id strings
+		 * or `{ id, name?, required? }`). Falls back to the injected manifest's
+		 * `dependencies`. A missing REQUIRED one replaces every step with the
+		 * dependency list and disables Next; a missing optional one is listed
+		 * on the first step and does not block.
+		 *
+		 * @type {Array<string|object>}
+		 * @spec openspec/changes/setup-wizard-card-load-and-dependency-gate/specs/cn-setup-wizard/spec.md#requirement-the-wizard-checks-dependencies-before-any-step
+		 */
+		dependencies: {
+			type: Array,
+			default: () => [],
+		},
+
+		/** Load button label on a dataset card (`loadAction`). */
+		loadLabel: {
+			type: String,
+			default: () => translate('nextcloud-vue', 'Load'),
+		},
+
+		/** Load button label once that dataset loaded in this session. */
+		reloadLabel: {
+			type: String,
+			default: () => translate('nextcloud-vue', 'Load again'),
+		},
 	},
 
 	emits: ['complete', 'close', 'step-change', 'action-result'],
@@ -196,6 +239,9 @@ var script = {
 			actionResult: {},
 			localDone: {},
 			userTouched: {},
+			// Per-card load state for `loadAction` steps, keyed by `loadKey()`.
+			datasetRunning: {},
+			datasetResult: {},
 		}
 	},
 
@@ -213,11 +259,150 @@ var script = {
 				: this.dialogTitle
 		},
 
-		setupSteps() {
+		/**
+		 * Every well-formed step, before `requires` is applied.
+		 *
+		 * @return {Array<object>}
+		 */
+		declaredSteps() {
 			return (this.steps || []).filter((s) => s && s.id && s.type)
 		},
 
+		/**
+		 * Steps that declare `requires` on an app that is not installed and
+		 * enabled. They are not offered; the summary names them as skipped.
+		 *
+		 * @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
+		 */
+		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);
+					return { step, missing }
+				})
+				.filter((entry) => entry.missing.length > 0)
+		},
+
+		setupSteps() {
+			const skipped = new Set(this.skippedSteps.map((entry) => entry.step.id));
+			return this.declaredSteps.filter((s) => !skipped.has(s.id))
+		},
+
+		/**
+		 * Id of the first offered step: where the optional-apps note shows.
+		 *
+		 * @return {string}
+		 */
+		firstStepId() {
+			return this.setupSteps.length > 0 ? this.setupSteps[0].id : ''
+		},
+
+		/**
+		 * The dependency declarations to check: the prop, else the manifest's.
+		 *
+		 * @return {Array<string|object>}
+		 */
+		dependencyEntries() {
+			if (Array.isArray(this.dependencies) && this.dependencies.length > 0) {
+				return this.dependencies
+			}
+			const fromManifest = this.cnManifest && this.cnManifest.dependencies;
+			return Array.isArray(fromManifest) ? fromManifest : []
+		},
+
+		/**
+		 * The `dependency_statuses` initial state an app may inject from PHP.
+		 * Same source CnAppRoot reads; `{}` when the app injects none.
+		 *
+		 * @return {object}
+		 */
+		serverAppStatuses() {
+			try {
+				return loadState(this.appId, 'dependency_statuses', {}) || {}
+			} catch {
+				return {}
+			}
+		},
+
+		/**
+		 * The declared dependencies with their live status.
+		 *
+		 * @return {Array<object>}
+		 */
+		dependencyRows() {
+			return checkDependencies(this.dependencyEntries, this.serverAppStatuses)
+		},
+
+		/** @return {Array<object>} Required dependencies that are missing or disabled. */
+		missingRequired() {
+			return this.dependencyRows.filter((d) => d.required && !isDependencyResolved(d))
+		},
+
+		/** @return {Array<object>} Optional dependencies that are missing or disabled. */
+		missingOptional() {
+			return this.dependencyRows.filter((d) => !d.required && !isDependencyResolved(d))
+		},
+
+		/**
+		 * Whether a required app is missing, so the wizard shows the
+		 * dependency list instead of its steps and refuses to continue.
+		 *
+		 * @return {boolean}
+		 * @spec openspec/changes/setup-wizard-card-load-and-dependency-gate/specs/cn-setup-wizard/spec.md#requirement-the-wizard-checks-dependencies-before-any-step
+		 */
+		dependencyBlocked() {
+			return this.missingRequired.length > 0
+		},
+
+		dependencyStepSlot() {
+			return 'step-' + DEPENDENCY_STEP_ID
+		},
+
+		dependencySectionName() {
+			return translate('nextcloud-vue', 'Apps this app needs')
+		},
+
+		dependencyBlockedText() {
+			return translate('nextcloud-vue', 'Setup can start once these apps are installed and enabled: {apps}.', {
+				apps: this.missingRequired.map((d) => d.name).join(', '),
+			})
+		},
+
+		optionalMissingText() {
+			return translate('nextcloud-vue', 'Optional, not installed: {apps}. You can add them later.', {
+				apps: this.missingOptional.map((d) => d.name).join(', '),
+			})
+		},
+
+		/**
+		 * Whether the current user is a Nextcloud admin; only admins get the
+		 * install and enable buttons.
+		 *
+		 * @return {boolean}
+		 */
+		isAdmin() {
+			try {
+				const user = getCurrentUser();
+				return !!(user && user.isAdmin)
+			} catch {
+				return false
+			}
+		},
+
 		wizardSteps() {
+			if (this.dependencyBlocked) {
+				return [{
+					id: DEPENDENCY_STEP_ID,
+					label: translate('nextcloud-vue', 'Required apps'),
+					optional: false,
+				}]
+			}
 			return this.setupSteps.map((s) => ({
 				id: s.id,
 				label: this.stepTitle(s),
@@ -241,6 +426,15 @@ var script = {
 		 * @return {Array<{ id: string, title: string, value: string, done: boolean, notRun: boolean }>}
 		 */
 		summaryItems() {
+			const skipped = this.skippedSteps
+				.filter((entry) => entry.step.type !== 'summary' && entry.step.type !== 'info')
+				.map((entry) => ({
+					id: entry.step.id,
+					title: this.stepTitle(entry.step),
+					value: translate('nextcloud-vue', 'Skipped, needs {apps}', { apps: entry.missing.join(', ') }),
+					done: false,
+					notRun: true,
+				}));
 			return this.setupSteps
 				.filter((s) => s.type !== 'summary')
 				.map((step) => {
@@ -277,6 +471,7 @@ var script = {
 					}
 					return { id: step.id, title: this.stepTitle(step), value, done, notRun: false }
 				})
+				.concat(skipped)
 		},
 
 		/**
@@ -337,6 +532,11 @@ var script = {
 		 * @return {void}
 		 */
 		maybeAutoRunStep(stepId) {
+			// Nothing runs while a required app is missing: every action
+			// would fail with an error that does not name the app.
+			if (this.dependencyBlocked) {
+				return
+			}
 			const step = this.setupSteps.find((s) => s.id === stepId);
 			if (step && step.type === 'run-action' && !this.isOnDemand(step) && !this.isStepDone(step.id) && !this.running[step.id]) {
 				this.runAction(step);
@@ -719,6 +919,131 @@ var script = {
 			}
 		},
 
+		/**
+		 * Key for one card's load state.
+		 *
+		 * @param {object} step The choice step.
+		 * @param {object} option The card's option.
+		 * @return {string}
+		 */
+		loadKey(step, option) {
+			return step.id + '::' + String(option && option.value)
+		},
+
+		/**
+		 * Whether a card gets a Load button: the step declares `loadAction`
+		 * and the option is not the "seed nothing" answer.
+		 *
+		 * @param {object} step The choice step.
+		 * @param {object} option The card's option.
+		 * @return {boolean}
+		 * @spec openspec/changes/setup-wizard-card-load-and-dependency-gate/specs/cn-setup-wizard/spec.md#requirement-a-dataset-card-loads-itself
+		 */
+		isLoadableOption(step, option) {
+			return !!(step && step.loadAction) && !!option && String(option.value) !== NONE_DATASET
+		},
+
+		isDatasetLoading(step, option) {
+			return this.datasetRunning[this.loadKey(step, option)] === true
+		},
+
+		datasetResultFor(step, option) {
+			return this.datasetResult[this.loadKey(step, option)] || null
+		},
+
+		loadButtonLabel(step, option) {
+			if (this.isDatasetLoading(step, option)) {
+				return this.runningLabel
+			}
+			const result = this.datasetResultFor(step, option);
+			return (result && result.success) ? this.reloadLabel : this.loadLabel
+		},
+
+		loadAriaLabel(option) {
+			return translate('nextcloud-vue', 'Load {name}', { name: option.label })
+		},
+
+		/**
+		 * Load one dataset from its card: POST `{ dataset }` to the step's
+		 * `loadAction`, spinner on the button while it runs, the result on the
+		 * card after. A successful load also selects the card, so the summary
+		 * and the stored choice name what was loaded.
+		 *
+		 * @param {object} step The choice step declaring `loadAction`.
+		 * @param {object} option The card's option.
+		 * @return {Promise<void>}
+		 * @spec openspec/changes/setup-wizard-card-load-and-dependency-gate/specs/cn-setup-wizard/spec.md#requirement-a-dataset-card-loads-itself
+		 */
+		async loadDataset(step, option) {
+			if (!this.isLoadableOption(step, option) || this.isDatasetLoading(step, option)) {
+				return
+			}
+			const key = this.loadKey(step, option);
+			this.datasetRunning[key] = true;
+			this.datasetResult[key] = null;
+			let result;
+			try {
+				const [{ default: axios }, { generateUrl }] = await Promise.all([
+					import('@nextcloud/axios'),
+					import('@nextcloud/router'),
+				]);
+				const { data } = await axios.post(
+					generateUrl(`/apps/${this.appId}/api/setup/action/${step.loadAction}`),
+					{ dataset: option.value },
+				);
+				result = {
+					success: !!data && data.success !== false,
+					message: (data && data.message) || translate('nextcloud-vue', 'Loaded.'),
+				};
+			} catch (err) {
+				result = { success: false, message: this.errorMessage(err) };
+			} finally {
+				this.datasetRunning[key] = false;
+			}
+			this.datasetResult[key] = result;
+			if (result.success) {
+				this.selectLoadedOption(step, option);
+				this.localDone[step.id] = true;
+			}
+			this.$emit('action-result', {
+				stepId: step.id,
+				action: step.loadAction,
+				dataset: option.value,
+				...result,
+			});
+		},
+
+		/**
+		 * Select a card that just loaded, adding to (never replacing) the
+		 * selection of a `multiple` step.
+		 *
+		 * @param {object} step The choice step.
+		 * @param {object} option The loaded option.
+		 * @return {void}
+		 */
+		selectLoadedOption(step, option) {
+			if (step.multiple === true) {
+				const current = this.cardModel(step);
+				if (current.some((v) => String(v) === String(option.value))) {
+					return
+				}
+				this.onChoice(step, current.concat([option.value]));
+				return
+			}
+			this.onChoice(step, option.value);
+		},
+
+		/**
+		 * A required app was installed from the dependency list. A new app's
+		 * scripts and its `OC.appswebroots` entry exist only after a full page
+		 * load, and `useAppStatus` caches per page, so reload.
+		 *
+		 * @return {void}
+		 */
+		onDependencyInstalled() {
+			window.location.reload();
+		},
+
 		/**
 		 * Whether a step is marked on-demand (`onDemand: true`): it runs only
 		 * when the user asks, never automatically, and the summary ticks it