@conduction/nextcloud-vue 2.83.0 → 2.85.0

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

@@ -11,16 +11,21 @@ import __sfc_main$1 from '../CnCellRenderer/CnGroupNameCell.vue.js';
 import __sfc_main$4 from '../CnFormDialog/CnFormDialog.vue.js';
 import { normalizeLook } from '../../composables/useLook.js';
 import { groupDisplayName, searchNextcloudGroups, loadGroupDisplayName } from '../../utils/groupAutocomplete.js';
+import { humaniseKey } from '../../utils/humaniseKey.js';
 import { PANEL_ACTION_SINK } from '../../utils/panelActions.js';
 import { resolveFilterTokens } from '../../utils/resolveFilterTokens.js';
 import { fieldsFromSchema, formatValue } from '../../utils/schema.js';
 import { schemaRefSlug } from '../../utils/schemaRefSlug.js';
 import { searchNextcloudUsers, resolveNextcloudUser } from '../../utils/userAutocomplete.js';
+import { isLocallyDecidableVisibleWhen, evaluateVisibleWhenLocal } from '../../utils/visibleWhen.js';
 import __sfc_main from '../CnIcon/CnIcon.vue.js';
 import __sfc_main$3 from '../CnObjectMetadataModal/CnObjectMetadataModal.vue.js';
 import __sfc_main$2 from '../CnWidgetWrapper/CnWidgetWrapper.vue.js';
 import { useObjectStore } from '../../store/useObjectStore.js';
 
+// Widgets whose value the inline text fallback would corrupt.
+const STRUCTURED_WIDGETS = ['json', 'code', 'file', 'sub-objects', 'child-records'];
+
 /**
  * CnObjectDataWidget — Schema-driven editable data grid widget.
  *
@@ -538,13 +543,18 @@ var script = {
 				gridRow: (this.resolvedOverrides[field.key] && this.resolvedOverrides[field.key].gridRow) || 1,
 			}));
 
+			// Per-field condition: `overrides[key].visibleWhen` shows a field only
+			// for the objects it belongs to, such as a person's preferred name on
+			// a client that can also be an organisation.
+			const shown = withSpans.filter((field) => this.isVisibleByCondition(field));
+
 			if (!this.hideEmpty) {
-				return withSpans
+				return shown
 			}
 
 			// Keep a field the user is currently editing or has pending changes for,
 			// otherwise it would vanish mid-edit the moment its value is cleared.
-			return withSpans.filter((field) => field.key === this.editingField
+			return shown.filter((field) => field.key === this.editingField
 				|| field.key in this.dirtyFields
 				|| !this.isEmptyValue((this.objectData || {})[field.key]))
 		},
@@ -956,6 +966,59 @@ var script = {
 			return (raw && typeof raw === 'object') ? Object.entries(raw) : []
 		},
 
+		/**
+		 * Whether a value is a plain object (not an array, not null).
+		 *
+		 * @param {unknown} v The value.
+		 * @return {boolean} True for a plain object.
+		 */
+		isPlainObject(v) {
+			return v !== null && typeof v === 'object' && !Array.isArray(v)
+		},
+
+		/**
+		 * Label for a key inside an object value: the sub-schema's `title`
+		 * (translated) when the schema describes it, else the key, made
+		 * readable when it is identifier-shaped (`shortDescription` → "Short
+		 * description"; `nl` stays `nl`).
+		 *
+		 * @param {object} field Resolved field definition.
+		 * @param {string[]} path Keys from the field's value down to this entry.
+		 * @return {string} The label.
+		 * @spec openspec/changes/data-widget-nested-objects/specs/data-widget-nested-objects/spec.md#requirement-a-nested-object-reads-as-a-list-per-key
+		 */
+		nestedLabel(field, path) {
+			let prop = ((this.schema && this.schema.properties) || {})[field.key];
+			for (const key of path) {
+				if (!this.isPlainObject(prop)) {
+					prop = null;
+					break
+				}
+				prop = (prop.properties && prop.properties[key])
+					|| (this.isPlainObject(prop.additionalProperties) ? prop.additionalProperties : null);
+			}
+			if (prop && typeof prop.title === 'string' && prop.title) {
+				return this.cnTranslate(prop.title)
+			}
+			const key = String(path[path.length - 1]);
+			return /[A-Z_-]/.test(key) ? humaniseKey(key) : key
+		},
+
+		/**
+		 * Stringify a value inside a definition list: a list of scalars reads
+		 * as a comma-separated line, anything else as `stringifyCell`.
+		 *
+		 * @param {unknown} v The value.
+		 * @return {string} The display string.
+		 * @spec openspec/changes/data-widget-nested-objects/specs/data-widget-nested-objects/spec.md#requirement-a-nested-object-reads-as-a-list-per-key
+		 */
+		stringifyNested(v) {
+			if (Array.isArray(v) && v.length && v.every((item) => item === null || typeof item !== 'object')) {
+				return v.map((item) => this.stringifyCell(item)).join(', ')
+			}
+			return this.stringifyCell(v)
+		},
+
 		/**
 		 * Stringify a scalar cell value; a nested object/array collapses to
 		 * compact JSON (never "[object Object]").
@@ -1283,15 +1346,53 @@ var script = {
 			}));
 		},
 
+		/**
+		 * Whether a field's value cannot be edited inline: a structured widget
+		 * (json, code, file, sub-objects, child-records), or a plain-object /
+		 * list-of-objects value that is not a relation. Scalar widgets without
+		 * a dedicated editor (duration, language, …) keep the text fallback.
+		 *
+		 * @param {object} field Resolved field definition.
+		 * @return {boolean} True when only the form dialog can edit it.
+		 * @spec openspec/changes/data-widget-nested-objects/specs/data-widget-nested-objects/spec.md#requirement-a-structured-value-is-never-edited-inline
+		 */
+		hasNoInlineEditor(field) {
+			if (STRUCTURED_WIDGETS.includes(field.widget)) {
+				return true
+			}
+			const prop = ((this.schema && this.schema.properties) || {})[field.key];
+			if (this.isRelationField(prop)) {
+				return false
+			}
+			// A list of objects by schema, also while empty (it resolves to `tags`).
+			if (prop && prop.type === 'array' && prop.items && prop.items.type === 'object') {
+				return true
+			}
+			// Classify the raw value itself: fieldValueKind reports a formatter
+			// field as 'scalar' whatever it holds.
+			const raw = this.rawOf(field);
+			if (Array.isArray(raw)) {
+				return raw.some((v) => this.isPlainObject(v))
+			}
+			return this.isPlainObject(raw)
+		},
+
 		/**
 		 * Check if a field is editable.
 		 *
 		 * @param {object} field - Resolved field definition from resolvedFields
+		 * @spec openspec/changes/data-widget-nested-objects/specs/data-widget-nested-objects/spec.md#requirement-a-structured-value-is-never-edited-inline
 		 */
 		isEditable(field) {
 			if (!this.editable) {
 				return false
 			}
+			// No inline editor exists for structured values: the text fallback
+			// would commit "[object Object]". Those edit through the form dialog,
+			// unless the consumer supplies its own `field-<key>` editor slot.
+			if (!this.$slots['field-' + field.key] && this.hasNoInlineEditor(field)) {
+				return false
+			}
 			// Per-field override takes priority
 			const override = this.resolvedOverrides[field.key];
 			if (override && typeof override.editable === 'boolean') {
@@ -1308,6 +1409,29 @@ var script = {
 			return !field.readOnly
 		},
 
+		/**
+		 * Evaluate a field's `visibleWhen` override against the object.
+		 *
+		 * The rule is the shared visibility predicate in its LOCAL mode
+		 * (`{ field, op, value }`, `all` / `any`, `appInstalled`), evaluated by
+		 * `evaluateVisibleWhenLocal` against the object with its unsaved
+		 * changes, so a field appears or goes the moment the field it depends
+		 * on changes. A rule that needs a request (`endpoint`, `source`) cannot
+		 * be decided here and is ignored: the field shows, as it did before
+		 * the rule existed.
+		 *
+		 * @param {object} field - Resolved field definition.
+		 * @return {boolean} True when the field is shown.
+		 */
+		isVisibleByCondition(field) {
+			const override = this.resolvedOverrides[field.key];
+			const rule = override ? override.visibleWhen : undefined;
+			if (rule === undefined || rule === null || !isLocallyDecidableVisibleWhen(rule)) {
+				return true
+			}
+			return evaluateVisibleWhenLocal(rule, { ...(this.objectData || {}), ...this.dirtyFields })
+		},
+
 		/**
 		 * Evaluate a field's conditional read-only rule against the object data.
 		 *