@conduction/nextcloud-vue 2.83.0 → 2.85.0

package/src/components/CnIndexPage/useSelfFetchList.js

@@ -26,6 +26,15 @@ function resolveInitialQuickFilterIndex(quickFilters) {
  * @param {Array<object>} filterMaps Already route-resolved filter maps.
  * @return {object} The merged filter (scalar when a key has one value, array when many).
  */
+/**
+ * Rows one board fetch asks for. A board shows every matching row at once,
+ * so it loads far more than a table page (OpenRegister serves up to 1000);
+ * past this the board offers "Load more".
+ *
+ * @type {number}
+ */
+export const BOARD_PAGE_SIZE = 500
+
 /**
  * The sort a quick filter sets while it is active (`sort: { key, order }`, or a
  * list of those for a multi-column order), as sort keys, or null when it sets
@@ -236,7 +245,7 @@ export function useSelfFetchList(props, instance, inject, extras = {}) {
 		defaultSortKeys: initialSortKeys,
 		defaultActiveFilters: initialActiveFilters,
 		defaultSearchTerm: initialSearchTerm,
-		defaultPageSize: (props.pagination && props.pagination.limit) || undefined,
+		defaultPageSize: props.viewMode === 'board' ? BOARD_PAGE_SIZE : ((props.pagination && props.pagination.limit) || undefined),
 		defaultVisibleColumns: configuredColumnKeys.length ? configuredColumnKeys : null,
 		// `pages[].config.extend` → OpenRegister's repeated `_extend[]`. A
 		// getter so a reactive change re-scopes the next fetch, matching how

package/src/components/CnInteractionFormWidget/CnInteractionFormWidget.vue

@@ -183,7 +183,7 @@ export default {
 		/** Channel options `{ value, label }`. */
 		channelOptions() {
 			return Array.isArray(this.content.channels) && this.content.channels.length > 0
-				? this.content.channels
+				? this.content.channels.map((channel) => ({ ...channel, label: this.copy(channel && channel.label) }))
 				: [
 						{ value: 'telefoon', label: t('nextcloud-vue', 'Phone') },
 						{ value: 'email', label: t('nextcloud-vue', 'Email') },
@@ -204,10 +204,11 @@ export default {
 			const prop = properties[this.content.outcomeField || 'outcome']
 			if (prop && Array.isArray(prop.enum) && prop.enum.length > 0) {
 				const labels = prop['x-enum-labels'] || prop.enumLabels || {}
-				const tr = typeof this.cnTranslate === 'function' ? this.cnTranslate : (k) => k
-				return prop.enum.map((value) => ({ value, label: tr(labels[value] || String(value)) }))
+				return prop.enum.map((value) => ({ value, label: this.copy(labels[value] || String(value)) }))
 			}
-			return Array.isArray(this.content.outcomes) ? this.content.outcomes : []
+			return Array.isArray(this.content.outcomes)
+				? this.content.outcomes.map((outcome) => ({ ...outcome, label: this.copy(outcome && outcome.label) }))
+				: []
 		},
 
 		/**
@@ -280,8 +281,7 @@ export default {
 		// `content.submitLabel` names what the form creates, e.g. "Save contact moment".
 		registerLabel() {
 			if (this.content.submitLabel) {
-				const tr = typeof this.cnTranslate === 'function' ? this.cnTranslate : (k) => k
-				return tr(this.content.submitLabel)
+				return this.copy(this.content.submitLabel)
 			}
 			return t('nextcloud-vue', 'Register')
 		},
@@ -359,6 +359,29 @@ export default {
 		},
 
 		/** The default channel value (first configured channel, else `telefoon`). */
+		/**
+		 * A label the manifest supplies (a channel, an outcome, the submit
+		 * label), translated: the app's own translation first, since the words
+		 * are the app's, then the library's catalogue, then the text as
+		 * written. Before, a channel label was shown as written and the submit
+		 * label only reached the app's translate, so pipelinq showed "Phone"
+		 * and "Save contact moment" in English to a Dutch reader.
+		 *
+		 * @spec openspec/changes/interaction-form-fits-and-reads-dutch/specs/interaction-form-widget/spec.md#requirement-the-interaction-form-fits-its-card-and-reads-in-the-readers-language
+		 * @param {string} key The label as the manifest writes it.
+		 * @return {string} The translated label.
+		 */
+		copy(key) {
+			if (typeof key !== 'string' || key === '') {
+				return key
+			}
+			const host = typeof this.cnTranslate === 'function' ? this.cnTranslate(key) : key
+			if (typeof host === 'string' && host !== '' && host !== key) {
+				return host
+			}
+			return t('nextcloud-vue', key)
+		},
+
 		firstChannel() {
 			const ch = (this.content && this.content.channels) || []
 			return (Array.isArray(ch) && ch.length > 0 && ch[0].value) || 'telefoon'

package/src/components/CnObjectDataWidget/CnObjectDataWidget.md

@@ -121,7 +121,7 @@ export default {
 | `icon` | Object\|Function | `null` | MDI icon component shown in the card header |
 | `objectType` | String | `''` | Registered object type slug used by `objectStore.saveObject()` |
 | `store` | Object | `null` | Explicit Pinia objectStore instance; auto-detected via Pinia when omitted |
-| `overrides` | Object | `{}` | Per-property config: `{ key: { order, gridColumn, gridRow, hidden, editable, label, widget } }` |
+| `overrides` | Object | `{}` | Per-property config: `{ key: { order, gridColumn, gridRow, hidden, editable, label, widget, visibleWhen } }`. `visibleWhen` shows the field only when the shared visibility predicate holds for this object, in its local mode: `{ field, op, value }` (ops `eq`, `neq`, `in`, `empty`, ...), or `all` / `any` of those. It reads unsaved changes too. A rule that needs a request (`endpoint`, `source`) is ignored. Read grid only: the Edit form still offers the field. |
 | `columns` | Number | `3` | Number of CSS grid columns in the widget |
 | `collapsedFields` (`collapsed-fields`) | Number | `null` | Number of fields shown while collapsed, with a "Show all N fields" button for the rest. `null` fits the cell: the whole rows that fit stay, and the button only appears when the cell overflows |
 | `hideEmpty` | Boolean | `false` | Hide fields with no value instead of rendering an em dash. For discriminated supertypes (one `ticket` schema holding request/complaint/contactmoment), so the grid is type-aware without the schema enumerating which fields belong to which variant. Read grid only — the field being edited, a field with unsaved changes, and the Edit form stay visible; `false`/`0` are values and are never hidden. |

package/src/components/CnObjectDataWidget/CnObjectDataWidget.vue

@@ -339,16 +339,30 @@
 									{{ stringifyCell(v) }}
 								</span>
 							</div>
-							<!-- Single plain OBJECT → key: value definition list. -->
+							<!-- Single plain OBJECT → key: value definition list; a
+							     nested plain object (e.g. a per-language map) gets
+							     its own list one level down. -->
 							<dl
 								v-else-if="fieldValueKind(field) === 'object'"
 								class="cn-object-data-widget__deflist">
 								<template v-for="(pair, pi) in objectEntries(rawOf(field))" :key="pi">
 									<dt>
-										{{ pair[0] }}
+										{{ nestedLabel(field, [pair[0]]) }}
 									</dt>
 									<dd>
-										{{ stringifyCell(pair[1]) }}
+										<dl
+											v-if="isPlainObject(pair[1])"
+											class="cn-object-data-widget__deflist cn-object-data-widget__deflist--nested">
+											<template v-for="(sub, si) in objectEntries(pair[1])" :key="si">
+												<dt>
+													{{ nestedLabel(field, [pair[0], sub[0]]) }}
+												</dt>
+												<dd>
+													<span class="cn-object-data-widget__deflist-text">{{ stringifyNested(sub[1]) }}</span>
+												</dd>
+											</template>
+										</dl>
+										<span v-else class="cn-object-data-widget__deflist-text">{{ stringifyNested(pair[1]) }}</span>
 									</dd>
 								</template>
 							</dl>
@@ -413,15 +427,20 @@ import CnFormDialog from '../CnFormDialog/CnFormDialog.vue'
 import { normalizeLook } from '../../composables/useLook.js'
 import { useObjectStore } from '../../store/index.js'
 import { groupDisplayName, loadGroupDisplayName, searchNextcloudGroups } 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 { resolveNextcloudUser, searchNextcloudUsers } from '../../utils/userAutocomplete.js'
+import { evaluateVisibleWhenLocal, isLocallyDecidableVisibleWhen } from '../../utils/visibleWhen.js'
 import { CnIcon } from '../CnIcon/index.js'
 import { CnObjectMetadataModal } from '../CnObjectMetadataModal/index.js'
 import { CnWidgetWrapper } from '../CnWidgetWrapper/index.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.
  *
@@ -939,13 +958,18 @@ export default {
 				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]))
 		},
@@ -1357,6 +1381,59 @@ export default {
 			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]").
@@ -1684,15 +1761,53 @@ export default {
 			}))
 		},
 
+		/**
+		 * 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') {
@@ -1709,6 +1824,29 @@ export default {
 			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.
 		 *
@@ -2410,6 +2548,17 @@ export default {
 	overflow-wrap: anywhere;
 }
 
+/* A long description keeps its own paragraphs. Set on an inline span with no
+   surrounding template whitespace, so only the value's own line breaks show. */
+.cn-object-data-widget__deflist-text {
+	white-space: pre-wrap;
+}
+
+.cn-object-data-widget__deflist--nested {
+	padding-inline-start: 8px;
+	border-inline-start: 2px solid var(--color-border);
+}
+
 /* Responsive: collapse to single column on narrow widths */
 @media (max-width: 600px) {
 	.cn-object-data-widget__grid {

package/src/components/CnRecordListWidget/CnRecordListWidget.vue

@@ -141,9 +141,11 @@
 import { subscribe, unsubscribe } from '@nextcloud/event-bus'
 import { translate as t } from '@nextcloud/l10n'
 import { NcLoadingIcon } from '@nextcloud/vue'
+import { inject, ref } from 'vue'
 import ChevronRight from 'vue-material-design-icons/ChevronRight.vue'
 import CnIcon from '../CnIcon/CnIcon.vue'
 import CnStatusBadge from '../CnStatusBadge/CnStatusBadge.vue'
+import { useEndpointSource } from '../../composables/useEndpointSource.js'
 import { actionLink, dispatchAction, interpolateActionTarget } from '../../utils/actionsDispatcher.js'
 import { isBadgeVariant } from '../../utils/badgeVariants.js'
 import { ageInDays } from '../../utils/boardDate.js'
@@ -180,7 +182,8 @@ function unwrap(value) {
  * objects filtered on a reference to this record. The source keys are those of
  * `object-list` (`register`, `schema`, `filter` with the `@objectId` /
  * `@object.<field>` / `@workspace.<key>` tokens, `sort`, `limit`, `extend`,
- * `rowRoute`, `pageControls`); `avatar` puts a circle with the initials of a name
+ * `rowRoute`, `pageControls`), or `endpointSource` (an app endpoint whose
+ * payload, after `responsePath`, is the array of rows, as on the object table); `avatar` puts a circle with the initials of a name
  * template before the title; what differs is the drawing: `presentation` is `rows`, `feed`
  * or `inline`, and each line is a template (`"{identifier} · {caseTypeName}"`,
  * `"Termijn {deadline|date}"`).
@@ -212,7 +215,11 @@ export default {
 		/**
 		 * The list config: `{ register, schema, filter?, sort?, limit?, extend?,
 		 * presentation?, title?, meta?, text?, label?, pill?, trailing?, icon?,
-		 * rowRoute?, rowIdField?, headerLink?, headerNote?, emptyText?, errorText? }`.
+		 * rowRoute?, rowIdField?, headerLink?, headerNote?, emptyText?, errorText?,
+		 * valueLabels?, endpointSource? }`. `endpointSource` (`{ url, method?,
+		 * params?, responsePath? }`) reads the rows from an app endpoint instead
+		 * of `register` / `schema`. `valueLabels` maps a field's stored values to the labels
+		 * the templates show.
 		 *
 		 * @type {object}
 		 */
@@ -236,6 +243,28 @@ export default {
 
 	emits: ['header'],
 
+	setup(props) {
+		const objectCtxRaw = inject('cnObjectContext', null)
+		const workspaceRaw = inject('cnWorkspaceContext', null)
+		const appConfigRaw = inject('cnAppConfig', ref({}))
+		const { data, loading, error } = useEndpointSource(
+			() => props.content?.endpointSource || null,
+			{
+				ctx: () => {
+					const injected = unwrap(objectCtxRaw) || {}
+					return {
+						...injected,
+						objectId: props.objectId ?? injected.objectId ?? props.objectData?.id ?? null,
+						object: props.objectData || injected.object || null,
+						workspace: unwrap(workspaceRaw) || {},
+						config: unwrapAppConfig(appConfigRaw) || {},
+					}
+				},
+			},
+		)
+		return { epData: data, epLoading: loading, epError: error }
+	},
+
 	data() {
 		return {
 			rows: [],
@@ -292,6 +321,22 @@ export default {
 			return { config: unwrapAppConfig(this.cnAppConfig) }
 		},
 
+		/**
+		 * Whether the rows come from `endpointSource` rather than OpenRegister.
+		 *
+		 * @return {boolean}
+		 * @spec openspec/changes/endpoint-source-card-grid-record-list/specs/dashboard-page/spec.md#requirement-a-record-list-and-a-card-grid-can-read-an-endpoint
+		 */
+		endpointActive() {
+			const source = this.content?.endpointSource
+			return Boolean(source && typeof source === 'object' && source.url)
+		},
+
+		/** @return {string} The endpoint read's state, to copy into the list when it changes. */
+		endpointKey() {
+			return this.endpointActive ? JSON.stringify([this.epData, this.epLoading, this.epError]) : ''
+		},
+
 		/** @return {number} The fetch cap. */
 		limit() {
 			const value = Number(this.content?.limit)
@@ -396,6 +441,10 @@ export default {
 		requestKey() {
 			this.fetchRows()
 		},
+
+		endpointKey() {
+			this.fetchRows()
+		},
 	},
 
 	mounted() {
@@ -441,7 +490,40 @@ export default {
 		 * @return {string} The text, '' when a token is empty.
 		 */
 		fill(template, row) {
-			return typeof template === 'string' && template !== '' ? fillTemplate(this.translate(template), row, new Date(), this.templateContext) : ''
+			return typeof template === 'string' && template !== '' ? fillTemplate(this.translate(template), this.labelledRow(row), new Date(), this.templateContext) : ''
+		},
+
+		/**
+		 * The row as the templates read it: a field named in `valueLabels`
+		 * (`{ channel: { phone: "Phone", telefoon: "Phone" } }`) shows the
+		 * translated label of its stored value, so "{channel}" reads "Telefoon"
+		 * for both spellings the data holds. A value without a label stays as
+		 * stored. The pill, the badges and the sort read the stored value.
+		 *
+		 * @param {object} row The row.
+		 * @return {object} The row, or a shallow copy with labelled fields.
+		 * @spec openspec/changes/screens-record-list-value-labels/specs/record-list-value-labels/spec.md#requirement-a-record-list-template-can-show-a-label-for-a-stored-value
+		 */
+		labelledRow(row) {
+			const map = this.content?.valueLabels
+			if (!row || typeof row !== 'object' || !map || typeof map !== 'object') {
+				return row
+			}
+			let out = row
+			for (const [field, labels] of Object.entries(map)) {
+				const raw = row[field]
+				if (!labels || typeof labels !== 'object' || (typeof raw !== 'string' && typeof raw !== 'number')) {
+					continue
+				}
+				const label = labels[String(raw)]
+				if (typeof label === 'string' && label !== '') {
+					if (out === row) {
+						out = { ...row }
+					}
+					out[field] = this.translate(label)
+				}
+			}
+			return out
 		},
 
 		/**
@@ -819,6 +901,23 @@ export default {
 			return { rows, total: typeof head.total === 'number' ? head.total : rows.length }
 		},
 
+		/**
+		 * Copy the endpoint read into the list: its payload must be an array of
+		 * rows (anything else is an empty list), and a failed read is an error.
+		 *
+		 * @spec openspec/changes/endpoint-source-card-grid-record-list/specs/dashboard-page/spec.md#requirement-a-record-list-and-a-card-grid-can-read-an-endpoint
+		 */
+		takeEndpointRows() {
+			this.rows = Array.isArray(this.epData) ? this.epData : []
+			this.total = this.rows.length
+			this.loading = this.epLoading === true
+			this.error = Boolean(this.epError)
+			this.lenses = {}
+			if (!this.loading) {
+				this.emitHeader()
+			}
+		},
+
 		/**
 		 * Fetch the list. Sends nothing while a required token is unresolved
 		 * or the source is incomplete.
@@ -827,6 +926,10 @@ export default {
 		 */
 		async fetchRows() {
 			const c = this.content || {}
+			if (this.endpointActive) {
+				this.takeEndpointRows()
+				return
+			}
 			if (!c.register || !c.schema || this.waiting) {
 				this.rows = []
 				this.total = 0

package/src/components/CnRegisterMapping/CnRegisterMapping.md

@@ -111,6 +111,10 @@ export default {
 </script>
 ```
 
+## Several groups
+
+With more than one group each group starts closed: its heading is a button that shows the group name and how many of its types are configured ("2/8 configured"), and opens the register select and type list on a click or Enter. A page with several registers is a short card until the administrator opens the group they need.
+
 ## Additional props
 
 | Prop | Type | Default | Description |
@@ -122,5 +126,6 @@ export default {
 | `reimporting` | Boolean | `false` | Disables the reimport button and shows a spinner while reimport is in progress |
 | `saveButtonText` | String | `'Save configuration'` | Label for the save button |
 | `reimportButtonText` | String | `'Re-import configuration'` | Label for the reimport button |
+| `collapseGroups` | Boolean | `null` | Draw each group as a heading button that opens and closes it, with its configured count shown while closed; the groups start closed. `null` does this when there is more than one group, `true` or `false` forces it |
 | `autoMatch` | Boolean | `true` | Automatically match schema titles to type slugs when a register is selected |
 | `labels` | Object | *(see below)* | UI label overrides for all user-visible strings (register, schema, notConfigured, noSchemas, selectRegister, selectSchema, allConfigured, partiallyConfigured) |