@conduction/nextcloud-vue 2.85.0 → 2.87.0

package/src/utils/boardColumns.js

@@ -55,12 +55,28 @@ export function stagesOf(field, colorField = '') {
 					label: String(entry?.label ?? entry?.title ?? entry?.key ?? entry?.value ?? ''),
 					hidden: entry?.hidden === true,
 					color: colorOf(field, entry, colorField),
+					capacity: capacityValue(entry?.capacity),
 				}))
 		.filter((stage) => stage.key !== '')
 
 	return { stages, usable: stages.length > 0 }
 }
 
+/**
+ * A column limit as a usable number.
+ *
+ * @param {unknown} value - The declared limit.
+ * @return {number|null} The limit, or null when there is none (not a number above 0).
+ * @spec openspec/changes/board-column-capacity/specs/board-view/spec.md#requirement-a-column-can-carry-a-capacity
+ */
+export function capacityValue(value) {
+	if (value === null || value === undefined || value === '') {
+		return null
+	}
+	const n = Number(value)
+	return Number.isFinite(n) && n > 0 ? n : null
+}
+
 /**
  * The colour a state declares: the `colorField` key on the state, else its
  * `color`, else (for a plain enum value) the field's `enumColors` entry.
@@ -154,6 +170,7 @@ export function buildBoardColumns({
 		key: stage.key,
 		label: stage.label,
 		color: stage.color,
+		capacity: stage.capacity ?? null,
 		cards: [],
 		count: 0,
 	}))
@@ -177,3 +194,35 @@ export function buildBoardColumns({
 
 	return { columns, usable: true }
 }
+
+/**
+ * Where a card may move, from what `allowedMoves` answered: plain column keys
+ * and `{ key, allowed, reason }` entries. A key any entry allows is allowed;
+ * a blocked key keeps the first reason given for it.
+ *
+ * @param {unknown} answer The answer.
+ * @return {{keys: Array<string>, reasons: object}|null} The allowed keys and the reasons by key, or null for everywhere.
+ * @spec openspec/changes/board-move-block-reasons/specs/board-view/spec.md#requirement-a-move-target-can-be-blocked-with-a-reason
+ */
+export function normalizeAllowed(answer) {
+	if (!Array.isArray(answer)) {
+		return null
+	}
+	const keys = []
+	const reasons = {}
+	for (const entry of answer) {
+		if (entry && typeof entry === 'object') {
+			const key = String(entry.key ?? '')
+			if (entry.allowed === false) {
+				if (!reasons[key] && typeof entry.reason === 'string' && entry.reason.trim() !== '') {
+					reasons[key] = entry.reason.trim()
+				}
+			} else {
+				keys.push(key)
+			}
+		} else if (entry !== null && entry !== undefined) {
+			keys.push(String(entry))
+		}
+	}
+	return { keys, reasons }
+}

package/src/utils/boardReferenceColumns.js

@@ -27,6 +27,7 @@
  * Pure apart from `fetchReferenceObjects`: no store, no Vue.
  */
 
+import { capacityValue } from './boardColumns.js'
 import { buildHeaders, buildQueryString, prefixUrl } from './headers.js'
 import { readPath } from './readPath.js'
 import { schemaRefSlug } from './schemaRefSlug.js'
@@ -124,7 +125,14 @@ export function referenceTargetOf(source, { register = '', property = null } = {
  * @param {string} [options.mergeBy] The row field whose equal values make one column.
  * @param {{field: string, rowField: string}|null} [options.narrowBy] The parent link.
  * @param {string} [options.narrowValue] The parent the board is narrowed to, '' for all.
- * @return {{states: Array<{key: string, label: string, color: string}>, keyByValue: Map<string, string>, refsByKey: Map<string, Array<object>>}} The stages.
+ * @param {string} [options.capacityField] The numeric row field that holds a column's limit.
+ *   A column merged from two or more rows shows none: each row has its own limit.
+ * @param {string} [options.neutralColor] The colour a row holds when nobody chose one. A merged
+ *   column then takes its first row colour that is not this one, and this one only when no row
+ *   has another. Compared as written: "Grey" is not "grey", and a hex value is not a name.
+ * @param {object} [options.colorMap] A stored colour to the CSS colour a column is drawn in,
+ *   applied after the merge. A colour it does not map is kept as stored.
+ * @return {{states: Array<{key: string, label: string, color: string, capacity?: (number|null)}>, keyByValue: Map<string, string>, refsByKey: Map<string, Array<object>>}} The stages.
  * @spec openspec/changes/screens-board-reference-columns/specs/board-view/spec.md#requirement-columns-can-be-the-rows-a-field-references
  */
 export function buildReferenceStages({
@@ -135,6 +143,9 @@ export function buildReferenceStages({
 	mergeBy = '',
 	narrowBy = null,
 	narrowValue = '',
+	capacityField = '',
+	neutralColor = '',
+	colorMap = null,
 } = {}) {
 	const list = (Array.isArray(refs) ? refs : []).filter((ref) => ref && typeof ref === 'object' && refIdOf(ref) !== '')
 	const narrowed = narrowBy && narrowBy.field && narrowValue !== ''
@@ -160,14 +171,114 @@ export function buildReferenceStages({
 		keyByValue.set(id, key)
 		if (!refsByKey.has(key)) {
 			refsByKey.set(key, [])
-			const color = colorField ? readPath(ref, colorField) : ref.color
-			states.push({ key, label, color: typeof color === 'string' ? color : '' })
+			const state = { key, label, color: colorOfRef(ref, colorField) }
+			if (capacityField) {
+				state.capacity = capacityOfRef(ref, capacityField)
+			}
+			states.push(state)
 		}
 		refsByKey.get(key).push(ref)
 	}
+	for (const state of states) {
+		const rows = refsByKey.get(state.key)
+		if (capacityField && rows.length > 1) {
+			state.capacity = null
+		}
+		if (neutralColor && rows.length > 1) {
+			state.color = mergedColumnColor(rows.map((ref) => colorOfRef(ref, colorField)), neutralColor, state.color)
+		}
+		state.color = mappedColor(state.color, colorMap)
+	}
 	return { states, keyByValue, refsByKey }
 }
 
+/**
+ * The colour one referenced row carries.
+ *
+ * @param {object} ref The referenced row.
+ * @param {string} colorField The row field that holds the colour, '' for `color`.
+ * @return {string} The colour, '' when it has none.
+ */
+function colorOfRef(ref, colorField) {
+	const color = colorField ? readPath(ref, colorField) : ref.color
+	return typeof color === 'string' ? color : ''
+}
+
+/**
+ * The colour a column merged from several rows takes when a neutral colour
+ * is declared: the first chosen colour, so a row stored with the default
+ * never outranks one somebody picked, whatever order the rows come in.
+ *
+ * @param {Array<string>} colors The rows' colours, in column order.
+ * @param {string} neutralColor The colour a row holds when nobody chose one.
+ * @param {string} fallback The colour when no row has a chosen or neutral one.
+ * @return {string} The column's colour.
+ * @spec openspec/changes/board-neutral-column-colour/specs/board-view/spec.md#requirement-a-merged-column-prefers-a-chosen-colour
+ */
+export function mergedColumnColor(colors, neutralColor, fallback = '') {
+	const chosen = colors.find((color) => color !== '' && color !== neutralColor)
+	if (chosen !== undefined) {
+		return chosen
+	}
+	return colors.includes(neutralColor) ? neutralColor : fallback
+}
+
+/**
+ * The CSS colour a stored colour maps to, so a palette name such as
+ * "orange" or "grey-light" can draw a theme token.
+ *
+ * @param {string} color The stored colour.
+ * @param {object|null} colorMap A stored colour to a CSS colour.
+ * @return {string} The mapped colour, else the stored one.
+ * @spec openspec/changes/board-column-colour-map/specs/board-view/spec.md#requirement-a-column-colour-can-be-mapped-to-a-css-colour
+ */
+export function mappedColor(color, colorMap) {
+	if (!colorMap || typeof colorMap !== 'object' || color === '' || !Object.hasOwn(colorMap, color)) {
+		return color
+	}
+	const mapped = colorMap[color]
+	return typeof mapped === 'string' && mapped !== '' ? mapped : color
+}
+
+/**
+ * The limit one referenced row declares.
+ *
+ * @param {object} ref The referenced row.
+ * @param {string} capacityField The row field that holds the limit.
+ * @return {number|null} The limit, or null when it has none.
+ * @spec openspec/changes/board-column-capacity/specs/board-view/spec.md#requirement-a-column-can-carry-a-capacity
+ */
+export function capacityOfRef(ref, capacityField) {
+	return capacityField ? capacityValue(readPath(ref, capacityField)) : null
+}
+
+/**
+ * Whether a drop fills a referenced row past its limit: the cards that
+ * already carry that row, counted against the row's own limit. Counted per
+ * row, not per column, so a column merged from several rows still refuses
+ * the one that is full.
+ *
+ * @param {object} options The call.
+ * @param {object} options.target The referenced row the drop would write.
+ * @param {object} options.card The card being moved.
+ * @param {Array<object>} options.rows The cards the board holds.
+ * @param {string} options.field The row field the columns come from.
+ * @param {string} options.capacityField The referenced row's limit field.
+ * @param {string} [options.rowKey] The row key, so the moving card is not counted.
+ * @return {{count: number, capacity: number}|null} The count and limit when full, else null.
+ * @spec openspec/changes/board-column-capacity/specs/board-view/spec.md#requirement-a-drop-into-a-full-column-is-refused
+ */
+export function fullTargetOf({ target, card, rows = [], field, capacityField, rowKey = 'id' } = {}) {
+	const capacity = capacityOfRef(target, capacityField)
+	if (capacity === null) {
+		return null
+	}
+	const id = refIdOf(target)
+	const self = String(card?.[rowKey] ?? '')
+	const count = (Array.isArray(rows) ? rows : []).filter((row) => String(row?.[rowKey] ?? '') !== self && refIdOf(readPath(row, field)) === id).length
+	return count >= capacity ? { count, capacity } : null
+}
+
 /**
  * The stages of a field with no referenced schema (a user id): the values
  * present on the rows, by label, then one column for no value.

package/src/utils/contentHeaderLink.js

@@ -46,3 +46,50 @@ export function contentHeaderLink(content) {
 	}
 	return link
 }
+
+/**
+ * The header link a widget DEFINITION declares: `headerLink` on the
+ * definition itself, else what its content asks for (see contentHeaderLink).
+ *
+ * @param {object|null|undefined} widget A widget definition.
+ * @return {{label: string, route?: string, params?: object, query?: object, href?: string}|null}
+ */
+export function widgetHeaderLink(widget) {
+	if (!widget || typeof widget !== 'object') {
+		return null
+	}
+	const declared = widget.headerLink
+	if (declared && typeof declared === 'object' && typeof declared.label === 'string' && declared.label !== '') {
+		return declared
+	}
+	return contentHeaderLink(widget.content)
+}
+
+/**
+ * How to draw a header link: the tag and its attributes. A `route` is a
+ * `router-link` (only when a router is mounted), an `href` a plain anchor.
+ * An empty tag means there is nothing usable to draw.
+ *
+ * @param {object|null|undefined} link A link `{ label, route?, params?, query?, href? }`.
+ * @param {boolean} hasRouter Whether a router is mounted.
+ * @return {{tag: string, attrs: object}}
+ */
+export function headerLinkTarget(link, hasRouter) {
+	if (!link || typeof link.label !== 'string' || link.label === '') {
+		return { tag: '', attrs: {} }
+	}
+	if (link.route && hasRouter) {
+		const to = { name: link.route }
+		if (link.params && typeof link.params === 'object') {
+			to.params = link.params
+		}
+		if (link.query && typeof link.query === 'object') {
+			to.query = link.query
+		}
+		return { tag: 'router-link', attrs: { to } }
+	}
+	if (typeof link.href === 'string' && link.href !== '') {
+		return { tag: 'a', attrs: { href: link.href } }
+	}
+	return { tag: '', attrs: {} }
+}

package/src/utils/schema.js

@@ -7,6 +7,7 @@
  */
 
 import { schemaRefSlug } from './schemaRefSlug.js'
+import { userLocale } from './userLocale.js'
 
 /**
  * Default column widths per property type/format.
@@ -159,7 +160,7 @@ export function formatValue(value, property = {}, options = {}) {
 		if (Number.isNaN(num)) {
 			return String(value)
 		}
-		return num.toLocaleString()
+		return num.toLocaleString(userLocale())
 	}
 
 	// Array
@@ -213,17 +214,17 @@ export function formatValue(value, property = {}, options = {}) {
 				return str
 			}
 			if (format === 'date') {
-				return date.toLocaleDateString(undefined, {
+				return date.toLocaleDateString(userLocale(), {
 					day: '2-digit',
 					month: '2-digit',
 					year: 'numeric',
 				})
 			}
-			return date.toLocaleDateString(undefined, {
+			return date.toLocaleDateString(userLocale(), {
 				day: '2-digit',
 				month: '2-digit',
 				year: 'numeric',
-			}) + ', ' + date.toLocaleTimeString(undefined, {
+			}) + ', ' + date.toLocaleTimeString(userLocale(), {
 				hour: '2-digit',
 				minute: '2-digit',
 				second: '2-digit',

package/src/utils/userLocale.js

@@ -0,0 +1,26 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ */
+
+import { getCanonicalLocale } from '@nextcloud/l10n'
+
+/**
+ * The BCP 47 tag dates and numbers are written in: the locale the user chose
+ * in Nextcloud (`nl_NL` becomes `nl-NL`), not the browser's.
+ *
+ * `toLocaleDateString(undefined)` answers in the BROWSER's locale, so a Dutch
+ * instance opened in an English browser wrote 10/15/2026. Pass this instead.
+ *
+ * @return {string|undefined} The tag, or undefined for the runtime default
+ *   when Nextcloud names none or Intl does not accept it.
+ * @spec openspec/changes/dates-in-the-users-locale/specs/data-display/spec.md#requirement-a-date-reads-in-the-users-nextcloud-locale
+ */
+export function userLocale() {
+	try {
+		const tag = getCanonicalLocale()
+		return tag && Intl.DateTimeFormat.supportedLocalesOf([tag]).length > 0 ? tag : undefined
+	} catch {
+		return undefined
+	}
+}