@conduction/nextcloud-vue 2.83.0 → 2.85.0

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

@@ -46,6 +46,7 @@ import { isAppInstalled } from '../../utils/appInstalled.js';
 import { compactLayoutRows } from '../../utils/dashboardPlacement.js';
 import { defaultDetailGrid } from '../../utils/defaultDetailGrid.js';
 import { stageOf, normalisePinnedAction, stageEntry, MAX_QUICK_ACTIONS, groupMenuEntries, resolveNextStep, pillCountSource, resolveCountPill, resolvePill } from '../../utils/detailActionModel.js';
+import { visibilityContextRefs, widgetConditionData, fetchVisibilityRows, detailWidgetVisible } from '../../utils/detailWidgetVisibility.js';
 import { reportBindingProblems } from '../../utils/diagnostics.js';
 import { fetchListTotal } from '../../utils/fetchFilterCounts.js';
 import { cnGridCellStyle, hasGridRow } from '../../utils/grid.js';
@@ -53,6 +54,7 @@ import { resolveHeaderMeta, isActivityWidget } from '../../utils/headerMeta.js';
 import { patchStoredSelf } from '../../utils/patchStoredSelf.js';
 import { setReadState } from '../../utils/recordInteractions.js';
 import { slotRenders } from '../../utils/slotContent.js';
+import { isLocallyDecidableVisibleWhen, evaluateVisibleWhen } from '../../utils/visibleWhen.js';
 import { isDataWidgetDef, isRelatedWidgetDef, isGeoWidgetDef, isContentOnlyWidgetDef, isCardWidgetDef, widgetContentOf, resolveRegistryRenderer, widgetTitleOf } from '../../utils/widgetDispatch.js';
 import __sfc_main$a from '../CnActionButtons/CnActionButtons.vue.js';
 import __sfc_main$b from '../CnBreadcrumbs/CnBreadcrumbs.vue.js';
@@ -296,8 +298,8 @@ var script = {
 
 	/**
 	 * Offer the board look's tab list name to the tabs widget below this page
-	 * (`config.tabsLabel`, default "<type> parts"). A getter object, so the
-	 * widget reads it live.
+	 * (`config.tabsLabel`, default "<type> parts"), and the records
+	 * `visibilityContext` names. Getter objects, so the widget reads them live.
 	 *
 	 * @return {object} The provided values.
 	 * @spec openspec/changes/screens-detail-page-parity/specs/detail-page-board-look/spec.md#requirement-folder-tabs-take-the-board-strip
@@ -305,6 +307,7 @@ var script = {
 	provide() {
 		const isBoard = computed(() => this.isBoard);
 		const tabsLabel = computed(() => this.resolvedTabsLabel);
+		const visibilityRows = computed(() => (this.visibilityRowsPending ? null : this.visibilityRows));
 		return {
 			// The page's own look reaches the tabs, the cards and the activity
 			// below it, also when it came from the `look` prop and not the app.
@@ -314,6 +317,15 @@ var script = {
 					return tabsLabel.value
 				},
 			},
+
+			// The records `visibilityContext` names, keyed `@context.<name>`, so a tab's
+			// `visibleWhen` reads the case type as a grid widget's does. Null
+			// while they are on their way.
+			cnDetailVisibilityRows: {
+				get value() {
+					return visibilityRows.value
+				},
+			},
 		}
 	},
 
@@ -1356,6 +1368,25 @@ var script = {
 			default: '',
 		},
 
+		/**
+		 * Records the page reads beside the loaded one, so a `visibleWhen`
+		 * can ask about them (manifest `config.visibilityContext`). Each entry
+		 * is `{ <name>: { field, register, schema } }`: `field` is the
+		 * property of the loaded record holding the other record's id, and a
+		 * condition reads that record as `@context.<name>.<path>`. A case page that
+		 * declares `{ caseType: { field: "caseType", register: "dossiq",
+		 * schema: "caseType" } }` can show a widget for some case types only
+		 * with `{ field: "@context.caseType.category", op: "in", value: [...] }`.
+		 * A record that cannot be read is absent, so its condition fails safe.
+		 * Empty (the default) reads nothing extra.
+		 *
+		 * @spec openspec/changes/detail-widgets-visible-when/specs/detail-widgets-visible-when/spec.md#requirement-a-detail-page-can-load-records-a-condition-names
+		 */
+		visibilityContext: {
+			type: Object,
+			default: () => ({}),
+		},
+
 		/**
 		 * Whether the current user administers this instance. Shows the
 		 * `adminOnly` header actions. `null` (the default) reads it from
@@ -1417,6 +1448,19 @@ var script = {
 			type: String,
 			default: '',
 		},
+
+		/**
+		 * The record field the header names the record by (manifest
+		 * `config.titleField`, a dotted path such as `number`), as an invoice
+		 * page names the invoice number. An empty value falls back to the
+		 * display name. Empty (the default) changes nothing.
+		 *
+		 * @spec openspec/changes/detail-title-field/specs/detail-page/spec.md#requirement-a-detail-page-can-name-the-record-by-a-field
+		 */
+		titleField: {
+			type: String,
+			default: '',
+		},
 	},
 
 	emits: [
@@ -1583,6 +1627,19 @@ var script = {
 
 	data() {
 		return {
+			/**
+			 * The records `visibilityContext` names, keyed `@context.<name>`: the row,
+			 * `null` when it could not be read, absent while it is on its way.
+			 */
+			visibilityRows: {},
+			/** The `visibilityRefsKey` the rows in `visibilityRows` were read for. */
+			visibilityRowsFor: '',
+			/** Sequence of the last `visibilityContext` read, so a late answer for another record is dropped. */
+			visibilityRowsSeq: 0,
+			/** The answers of endpoint and source `visibleWhen` conditions on grid widgets, by widget id. */
+			widgetConditionAnswers: {},
+			/** Sequence of the last remote condition round. */
+			widgetConditionSeq: 0,
 			/** The counts of the header's count pills (`countFrom`), by pill key (`type`, `status`). */
 			pillCounts: {},
 			/** Sequence of the last pill count round, so a late answer does not overwrite a newer one. */
@@ -1842,11 +1899,17 @@ var script = {
 		 * because a keyboard user who cannot see the page needs to know what
 		 * they are being offered before they take it.
 		 *
+		 * One library string with a placeholder, not "Skip to" from the host's
+		 * catalogue glued to the label: no app carried that fragment, so every
+		 * Dutch reader got "Skip to In behandeling nemen" (Zuiddrecht live
+		 * round 3), and a fragment cannot be put in Dutch word order anyway.
+		 *
 		 * @return {string} The link text.
 		 * @spec openspec/changes/case-page-and-list-as-a-place/specs/index-page/spec.md
+		 * @spec openspec/changes/detail-page-strings-dutch/specs/detail-page-strings-dutch/spec.md#requirement-the-detail-page-speaks-the-readers-language
 		 */
 		skipLinkLabel() {
-			return `${this.effectiveTranslate('Skip to')} ${this.effectivePrimaryLabel}`
+			return translate('nextcloud-vue', 'Skip to {action}', { action: this.effectivePrimaryLabel })
 		},
 
 		// ── The action model (detail-action-model-and-case-surfaces) ────
@@ -2688,6 +2751,68 @@ var script = {
 			return store.objects?.[this.objectType]?.[this.objectId] ?? null
 		},
 
+		/**
+		 * The records `visibilityContext` names for the loaded record.
+		 *
+		 * @return {Array<{key: string, register: string, schema: string, id: string}>}
+		 * @spec openspec/changes/detail-widgets-visible-when/specs/detail-widgets-visible-when/spec.md#requirement-a-detail-page-can-load-records-a-condition-names
+		 */
+		visibilityRefs() {
+			return visibilityContextRefs(this.visibilityContext, this.resolvedObject)
+		},
+
+		/**
+		 * Whether a record `visibilityContext` names is still on its way.
+		 *
+		 * @return {boolean}
+		 * @spec openspec/changes/detail-widgets-visible-when/specs/detail-widgets-visible-when/spec.md#requirement-a-detail-page-can-load-records-a-condition-names
+		 */
+		visibilityRowsPending() {
+			return this.visibilityRefs.length > 0 && this.visibilityRowsFor !== this.visibilityRefsKey
+		},
+
+		/**
+		 * The named references as one key, so another record (or another case
+		 * type on the same record) reads them again.
+		 *
+		 * @return {string}
+		 * @spec openspec/changes/detail-widgets-visible-when/specs/detail-widgets-visible-when/spec.md#requirement-a-detail-page-can-load-records-a-condition-names
+		 */
+		visibilityRefsKey() {
+			return JSON.stringify(this.visibilityRefs)
+		},
+
+		/**
+		 * What a grid widget's `visibleWhen` reads: the record, with the
+		 * `visibilityContext` records under `@context.<name>`. Null until the record loads.
+		 *
+		 * @return {object|null}
+		 * @spec openspec/changes/detail-widgets-visible-when/specs/detail-widgets-visible-when/spec.md#requirement-a-detail-grid-widget-shows-only-while-its-visiblewhen-holds-for-the-record
+		 */
+		widgetVisibilityData() {
+			return widgetConditionData(this.resolvedObject, this.visibilityRows)
+		},
+
+		/**
+		 * The grid widgets whose `visibleWhen` needs a request (endpoint or
+		 * source), with what they ask, as one key: a change re-asks them.
+		 *
+		 * @return {string}
+		 * @spec openspec/changes/detail-widgets-visible-when/specs/detail-widgets-visible-when/spec.md#requirement-a-detail-grid-widget-shows-only-while-its-visiblewhen-holds-for-the-record
+		 */
+		remoteWidgetConditionsKey() {
+			if (!this.widgetVisibilityData || this.visibilityRowsPending) {
+				return ''
+			}
+			const defs = [...(this.bodyGridWidgets || []), ...((this.activeView && this.activeView.widgets) || [])];
+			const remote = defs.filter((def) => def && def.visibleWhen && typeof def.visibleWhen === 'object'
+				&& !isLocallyDecidableVisibleWhen(def.visibleWhen));
+			if (remote.length === 0) {
+				return ''
+			}
+			return JSON.stringify([String(this.objectId || ''), remote.map((def) => [def.id, def.visibleWhen])])
+		},
+
 		/**
 		 * The `@self` block of the resolved object (interaction markers live here).
 		 *
@@ -2774,10 +2899,10 @@ var script = {
 		},
 
 		/**
-		 * The resolved record's human display name, drawn from the loaded
-		 * object via the same fallback chain the relation resolver uses:
-		 * `@self.name` → `name` / `title` / `displayName` → `firstName
-		 * lastName`. Empty string while the object is still loading or when no
+		 * The resolved record's human display name: the `titleField` value
+		 * when the page names one and it is filled, else the same fallback
+		 * chain the relation resolver uses: `@self.name` → `name` / `title` /
+		 * `displayName` → `firstName lastName`. Empty string while the object is still loading or when no
 		 * name-like field exists (a raw id is never used as a name — ADR-062).
 		 *
 		 * @return {string}
@@ -2787,6 +2912,12 @@ var script = {
 			if (!obj || typeof obj !== 'object') {
 				return ''
 			}
+			if (this.titleField) {
+				const named = stageOf(obj, this.titleField);
+				if (named !== '') {
+					return named
+				}
+			}
 			const self = obj['@self'] || {};
 			const id = this.objectId !== null && this.objectId !== undefined ? String(this.objectId) : '';
 			const candidates = [self.name, self.title, obj.name, obj.title, obj.displayName];
@@ -3220,6 +3351,22 @@ var script = {
 	},
 
 	watch: {
+		// The records a condition names are read again for another record.
+		visibilityRefsKey: {
+			immediate: true,
+			handler() {
+				this.refreshVisibilityRows();
+			},
+		},
+
+		// Endpoint and source conditions on grid widgets are asked once per record.
+		remoteWidgetConditionsKey: {
+			immediate: true,
+			handler() {
+				this.refreshWidgetConditions();
+			},
+		},
+
 		// The header's count pills count again for another record or other lists.
 		pillCountKey: {
 			immediate: true,
@@ -4458,6 +4605,62 @@ var script = {
 				|| undefined
 		},
 
+		/**
+		 * Read the records `visibilityContext` names for the loaded record. A
+		 * late answer for a record the page has left is dropped.
+		 *
+		 * @return {Promise<void>}
+		 * @spec openspec/changes/detail-widgets-visible-when/specs/detail-widgets-visible-when/spec.md#requirement-a-detail-page-can-load-records-a-condition-names
+		 */
+		async refreshVisibilityRows() {
+			const key = this.visibilityRefsKey;
+			const refs = this.visibilityRefs;
+			const seq = ++this.visibilityRowsSeq;
+			if (refs.length === 0) {
+				// Write only on a change, so a page without `visibilityContext`
+				// never touches the state its layout could read.
+				if (Object.keys(this.visibilityRows).length > 0) {
+					this.visibilityRows = {};
+				}
+				if (this.visibilityRowsFor !== key) {
+					this.visibilityRowsFor = key;
+				}
+				return
+			}
+			if (!this._visibilityRowCache) {
+				this._visibilityRowCache = new Map();
+			}
+			const rows = await fetchVisibilityRows(refs, this._visibilityRowCache);
+			if (seq !== this.visibilityRowsSeq) {
+				return
+			}
+			this.visibilityRows = rows;
+			this.visibilityRowsFor = key;
+		},
+
+		/**
+		 * Ask the endpoint and source `visibleWhen` conditions of the grid
+		 * widgets, once per record. Each is fail-safe: an error hides the widget.
+		 *
+		 * @return {Promise<void>}
+		 * @spec openspec/changes/detail-widgets-visible-when/specs/detail-widgets-visible-when/spec.md#requirement-a-detail-grid-widget-shows-only-while-its-visiblewhen-holds-for-the-record
+		 */
+		async refreshWidgetConditions() {
+			const seq = ++this.widgetConditionSeq;
+			if (this.remoteWidgetConditionsKey === '') {
+				return
+			}
+			const [, entries] = JSON.parse(this.remoteWidgetConditionsKey);
+			const ctx = { objectId: this.objectId, object: this.widgetVisibilityData || undefined };
+			const answers = {};
+			await Promise.all(entries.map(async ([id, cond]) => {
+				answers[id] = await evaluateVisibleWhen(cond, ctx);
+			}));
+			if (seq === this.widgetConditionSeq) {
+				this.widgetConditionAnswers = answers;
+			}
+		},
+
 		/**
 		 * Drop the items that draw nothing, then close the rows they freed —
 		 * `float: true` leaves the item below pinned under a gap nobody owns.
@@ -4480,7 +4683,10 @@ var script = {
 		 * Whether a layout item has anything to draw, so a grid cell is worth
 		 * spending on it.
 		 *
-		 * TWO widget types are judged, and no others.
+		 * A widget whose definition carries `visibleWhen` draws only while the
+		 * condition holds for the record (see `detailWidgetVisible`).
+		 *
+		 * Beyond that, TWO widget types are judged, and no others.
 		 *
 		 * `integration`, in the case where nothing can ever appear: a leaf from
 		 * another app that is not registered, with no `requiredApp` to fall back
@@ -4527,6 +4733,18 @@ var script = {
 			if (!widget) {
 				return true
 			}
+			// The widget's own `visibleWhen`, read against the record and the
+			// records `visibilityContext` names (a case's case type). Without
+			// one the widget shows, as it always did, and the layout takes no
+			// dependency on the record: a page without conditions re-lays out
+			// exactly as often as before.
+			if (widget.visibleWhen !== undefined && widget.visibleWhen !== null
+				&& !detailWidgetVisible(widget, this.widgetVisibilityData, {
+					pending: this.visibilityRowsPending,
+					answers: this.widgetConditionAnswers,
+				})) {
+				return false
+			}
 			// The board look shows the activity as the History tab. When a tabs
 			// widget already holds it, it is not also a body section.
 			if (this.isBoard && isActivityWidget(widget) && this.tabbedWidgetIds.has(widget.id)) {