@conduction/nextcloud-vue 2.61.0 → 2.63.0

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

@@ -12,7 +12,9 @@ import { TENANT_CONTEXT_KEY } from '../../composables/useTenantContext.js';
 import { useObjectStore } from '../../store/useObjectStore.js';
 import { extendsFormDeclarations, prefillDeclarations, definitionQueryParams, propertiesFromDefinitions, prefillValues, splitDynamicFormData, DYNAMIC_KEY_PREFIX } from '../../utils/dynamicProperties.js';
 import { shouldShow } from '../../utils/fieldCondition.js';
+import { resolveNextcloudGroup, searchNextcloudGroups } from '../../utils/groupAutocomplete.js';
 import { objectDisplayName } from '../../utils/objectName.js';
+import { resolveDefaultToken, languageOptions, timezoneOptions } from '../../utils/pickerOptions.js';
 import { resolveFilterTokens } from '../../utils/resolveFilterTokens.js';
 import { fieldsFromSchema, isTenantProperty } from '../../utils/schema.js';
 import { resolveNextcloudUser, searchNextcloudUsers } from '../../utils/userAutocomplete.js';
@@ -543,6 +545,13 @@ var script = {
 			 * `dynamicToken` guards the definitions fetch.
 			 */
 			prefillToken: '',
+			/**
+			 * The inline create in progress, or null: `{ field, schema,
+			 * register, slug, initialData, resolve }`. Set when "Create" is
+			 * chosen on a select-or-create reference; renders a nested form
+			 * for the referenced schema.
+			 */
+			nestedCreate: null,
 		}
 	},
 
@@ -813,6 +822,7 @@ var script = {
 				.filter((field) => shouldShow(field, this.formData))
 				.map((field) => this.applySemanticResolution(field))
 				.map((field) => this.degradeUnresolvableReference(field))
+				.map((field) => this.applyCodePicker(field))
 		},
 
 		/**
@@ -1327,11 +1337,16 @@ var script = {
 				// Create mode: initialize with field defaults
 				const data = {};
 				for (const field of this.resolvedFields) {
+					const tokenDefault = field.defaultToken ? resolveDefaultToken(field.defaultToken, field) : null;
 					if (field.default !== null && field.default !== undefined) {
 						data[field.key] = field.default;
+					} else if (tokenDefault !== null) {
+						// `x-default: current-language` / `current-timezone`:
+						// a NEW object starts with the user's own value.
+						data[field.key] = tokenDefault;
 					} else if (field.widget === 'checkbox') {
 						data[field.key] = false;
-					} else if (field.widget === 'tags' || field.widget === 'multiselect' || field.widget === 'user-multiselect') {
+					} else if (field.widget === 'tags' || field.widget === 'multiselect' || field.widget === 'user-multiselect' || field.widget === 'group-multiselect') {
 						data[field.key] = [];
 					} else if (field.widget === 'code') {
 						data[field.key] = '';
@@ -1398,10 +1413,35 @@ var script = {
 							this.resolveUserLabel(uid);
 						}
 					}
+				} else if (this.isGroupField(field) || this.isGroupArrayField(field)) {
+					const value = this.formData[field.key];
+					for (const gid of (Array.isArray(value) ? value : [value])) {
+						if (gid) {
+							this.resolveGroupLabel(gid);
+						}
+					}
 				}
 			}
 		},
 
+		/**
+		 * Resolve a stored group id to its display name and cache it in
+		 * `referenceLabels`. No-op once cached; falls back to the gid.
+		 *
+		 * @spec openspec/changes/form-pickers-from-schema/specs/schema-utilities/spec.md
+		 * @param {string} gid The stored group id.
+		 * @return {Promise<void>}
+		 */
+		async resolveGroupLabel(gid) {
+			if (!gid || this.referenceLabels[gid]) {
+				return
+			}
+			const option = await resolveNextcloudGroup(gid);
+			if (option && option.id) {
+				this.referenceLabels = { ...this.referenceLabels, [option.id]: option.label || String(option.id) };
+			}
+		},
+
 		/**
 		 * Resolve a single user UID to its display name (edit mode) and cache it
 		 * in `referenceLabels` so the select shows the name instead of the UID.
@@ -1898,6 +1938,67 @@ var script = {
 			return !!(field && field.userPicker && field.userPicker.multiple)
 		},
 
+		/**
+		 * Whether a field is a single Nextcloud group (`format: 'nc-group'` or
+		 * `referenceType: 'nextcloud-group'`). Stores the group id.
+		 *
+		 * @spec openspec/changes/form-pickers-from-schema/specs/schema-utilities/spec.md
+		 * @param {object} field The field definition
+		 * @return {boolean}
+		 */
+		isGroupField(field) {
+			return !!(field && field.groupPicker && !field.groupPicker.multiple)
+		},
+
+		/**
+		 * Whether a field is an array of Nextcloud groups.
+		 *
+		 * @spec openspec/changes/form-pickers-from-schema/specs/schema-utilities/spec.md
+		 * @param {object} field The field definition
+		 * @return {boolean}
+		 */
+		isGroupArrayField(field) {
+			return !!(field && field.groupPicker && field.groupPicker.multiple)
+		},
+
+		/**
+		 * Whether a single-value field stores an id that maps to a label
+		 * fetched elsewhere: an object reference, a user or a group.
+		 *
+		 * @param {object} field The field definition
+		 * @return {boolean}
+		 */
+		isIdPickerField(field) {
+			return this.isReferenceField(field) || this.isUserField(field) || this.isGroupField(field)
+		},
+
+		/**
+		 * The multi-value sibling of `isIdPickerField`.
+		 *
+		 * @param {object} field The field definition
+		 * @return {boolean}
+		 */
+		isIdPickerArrayField(field) {
+			return this.isReferenceArrayField(field) || this.isUserArrayField(field) || this.isGroupArrayField(field)
+		},
+
+		/**
+		 * Turn a language or time zone field into a searchable select over
+		 * a fixed code list: labels in the user's language, the code stored.
+		 * Other fields pass through unchanged.
+		 *
+		 * @spec openspec/changes/form-pickers-from-schema/specs/schema-utilities/spec.md
+		 * @param {object} field A resolved field descriptor.
+		 * @return {object} The field, as a `select` when it is a code picker.
+		 */
+		applyCodePicker(field) {
+			if (!field || (field.widget !== 'language' && field.widget !== 'timezone')) {
+				return field
+			}
+			const list = field.widget === 'language' ? languageOptions() : timezoneOptions();
+			return { ...field, widget: 'select', codePicker: field.widget, enum: list.codes, enumLabels: list.labels }
+		},
+
 		/**
 		 * Check if a field has an async enum (function instead of static array).
 		 * Object references (`$ref`) and Nextcloud user references are treated
@@ -1907,7 +2008,7 @@ var script = {
 		 * @return {boolean}
 		 */
 		isAsyncEnum(field) {
-			return typeof field.enum === 'function' || this.isReferenceField(field) || this.isUserField(field)
+			return typeof field.enum === 'function' || this.isIdPickerField(field)
 		},
 
 		/**
@@ -1919,7 +2020,7 @@ var script = {
 		 * @return {boolean}
 		 */
 		isAsyncItemsEnum(field) {
-			return !!(field.items && typeof field.items.enum === 'function') || this.isReferenceArrayField(field) || this.isUserArrayField(field)
+			return !!(field.items && typeof field.items.enum === 'function') || this.isIdPickerArrayField(field)
 		},
 
 		/**
@@ -1986,12 +2087,119 @@ var script = {
 		 * @return {void}
 		 */
 		onReferenceSelected(field, value) {
+			if (Array.isArray(value)) {
+				this.updateField(field.key, value);
+				return
+			}
 			this.updateField(field.key, value || null);
 			if (value) {
 				this.applyTemplateFill(field, value);
 			}
 		},
 
+		/**
+		 * The value CnResourceSelect binds for a select-or-create reference:
+		 * an array of ids for a multi-value reference, else the id string.
+		 *
+		 * @param {object} field The reference field descriptor.
+		 * @return {string|string[]} The bound value.
+		 */
+		referenceModelValue(field) {
+			const value = this.formData[field.key];
+			if (field.reference && field.reference.multiple) {
+				return Array.isArray(value) ? value.map((v) => String(v)) : []
+			}
+			return value !== null && value !== undefined ? String(value) : ''
+		},
+
+		/**
+		 * "Create" on a select-or-create reference: open the referenced
+		 * schema's own form, prefilled with the typed term, on top of this one.
+		 *
+		 * Resolves with the created object once that form is saved, or with
+		 * null when it is closed without saving. CnResourceSelect then selects
+		 * the new object. When the referenced schema cannot be loaded, the
+		 * term alone is saved as before, so the field never dead-ends.
+		 *
+		 * @spec openspec/changes/form-pickers-from-schema/specs/schema-utilities/spec.md
+		 * @param {object} field The reference field descriptor.
+		 * @param {string} term The typed search term.
+		 * @return {Promise<object|null>} The created object, or null.
+		 */
+		async openNestedCreate(field, term) {
+			const store = this.getObjectStore();
+			const register = this.referenceRegister(field);
+			if (!store || !register || !field.reference) {
+				return null
+			}
+			const schemaRef = String(field.reference.schema);
+			const slug = store.createObjectTypeSlug(register, schemaRef);
+			if (!store.objectTypeRegistry[slug]) {
+				store.registerObjectType(slug, schemaRef, register);
+			}
+			const labelField = this.referenceLabelField(field);
+			let schema = null;
+			try {
+				schema = await store.fetchSchema(slug);
+			} catch {
+				schema = null;
+			}
+			if (!schema || !schema.properties) {
+				return store.saveObject(slug, { [labelField]: term })
+			}
+			const initialData = {};
+			if (term && schema.properties[labelField]) {
+				initialData[labelField] = term;
+			}
+			return new Promise((resolve) => {
+				this.nestedCreate = { field, schema, register, slug, initialData, resolve };
+			})
+		},
+
+		/**
+		 * The nested create form was confirmed: save the object, hand it to
+		 * the waiting picker and close the nested form. A refused save keeps
+		 * the nested form open with the server's message.
+		 *
+		 * @spec openspec/changes/form-pickers-from-schema/specs/schema-utilities/spec.md
+		 * @param {object} formData The nested form's values.
+		 * @return {Promise<void>}
+		 */
+		async onNestedCreateConfirm(formData) {
+			const pending = this.nestedCreate;
+			if (!pending) {
+				return
+			}
+			const store = this.getObjectStore();
+			const created = store ? await store.saveObject(pending.slug, formData) : null;
+			if (!created) {
+				const error = store && store.errors ? store.errors[pending.slug] : null;
+				const message = (error && error.message)
+					|| translate('nextcloud-vue', 'The item could not be created.');
+				const dialog = this.$refs.nestedCreateDialog;
+				if (dialog && typeof dialog.setValidationErrors === 'function') {
+					dialog.setValidationErrors({}, message);
+				}
+				return
+			}
+			this.nestedCreate = null;
+			pending.resolve(created);
+		},
+
+		/**
+		 * The nested create form was closed without saving: leave the field
+		 * as it was.
+		 *
+		 * @return {void}
+		 */
+		onNestedCreateClose() {
+			const pending = this.nestedCreate;
+			this.nestedCreate = null;
+			if (pending) {
+				pending.resolve(null);
+			}
+		},
+
 		/**
 		 * Copy template values off a selected/created reference object into the
 		 * form, per the field's `fillFrom` map (`{ formKey: sourceKey }`). When
@@ -2438,9 +2646,14 @@ var script = {
 			}
 			this.asyncState = newState;
 
-			// Trigger initial load for each async field
+			// Trigger initial load for each async field. A select-or-create
+			// reference loads its own options (CnResourceSelect), so it is
+			// skipped here rather than fetched twice.
 			this.$nextTick(() => {
 				for (const field of fields) {
+					if (field.allowCreate && field.reference) {
+						continue
+					}
 					if (this.isAsyncEnum(field) || this.isAsyncItemsEnum(field)) {
 						this.loadAsyncOptions(field, '');
 					}
@@ -2481,6 +2694,18 @@ var script = {
 					if (Object.keys(labels).length > 0) {
 						this.referenceLabels = { ...this.referenceLabels, ...labels };
 					}
+				} else if (this.isGroupField(field) || this.isGroupArrayField(field)) {
+					// Nextcloud group: search groups, store the gid, show the name.
+					results = await searchNextcloudGroups(query);
+					const labels = {};
+					for (const opt of results) {
+						if (opt && opt.id) {
+							labels[opt.id] = opt.label || String(opt.id);
+						}
+					}
+					if (Object.keys(labels).length > 0) {
+						this.referenceLabels = { ...this.referenceLabels, ...labels };
+					}
 				} else {
 					const enumFn = typeof field.enum === 'function' ? field.enum : field.items.enum;
 					results = await enumFn(query);
@@ -2539,7 +2764,7 @@ var script = {
 		 * @return {object|null}
 		 */
 		getEffectiveSelectedOption(field) {
-			if (this.isReferenceField(field) || this.isUserField(field)) {
+			if (this.isIdPickerField(field)) {
 				// Reference / user fields store the UUID/UID — resolve it to a
 				// display option `{ id, label }` (label from the resolved-labels
 				// cache, falling back to the id until it loads).
@@ -2566,7 +2791,7 @@ var script = {
 		 * @param {object|null} option The selected option
 		 */
 		onEffectiveSelectChange(field, option) {
-			if (this.isReferenceField(field) || this.isUserField(field)) {
+			if (this.isIdPickerField(field)) {
 				// Reference / user fields store the chosen id (UUID / UID),
 				// not the full option. Cache its label so the selection displays.
 				if (option && option.id) {
@@ -2575,7 +2800,7 @@ var script = {
 				this.updateField(field.key, option ? option.id : null);
 				// Reference options are label-only ({id,label}) — pass the id so
 				// template pre-fill fetches the full object.
-				if (option && option.id) {
+				if (option && option.id && this.isReferenceField(field)) {
 					this.applyTemplateFill(field, String(option.id));
 				}
 			} else if (this.isAsyncEnum(field)) {
@@ -2607,7 +2832,7 @@ var script = {
 		 * @return {Array}
 		 */
 		getEffectiveSelectedArrayOptions(field) {
-			if (this.isReferenceArrayField(field) || this.isUserArrayField(field)) {
+			if (this.isIdPickerArrayField(field)) {
 				// Reference / user arrays store an array of ids (UUIDs / UIDs) —
 				// resolve each to a display option `{ id, label }`.
 				const uuids = this.formData[field.key];
@@ -2630,7 +2855,7 @@ var script = {
 		 * @param {Array} options The selected options
 		 */
 		onEffectiveMultiSelectChange(field, options) {
-			if (this.isReferenceArrayField(field) || this.isUserArrayField(field)) {
+			if (this.isIdPickerArrayField(field)) {
 				// Reference / user arrays store an array of ids (UUIDs / UIDs).
 				// Cache labels so the chips still display the human names.
 				const list = options || [];