@conduction/nextcloud-vue 2.61.0 → 2.63.0

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

@@ -1,16 +1,20 @@
 import axios__default from '@nextcloud/axios';
-import { translate } from '@nextcloud/l10n';
+import { translate, translatePlural } from '@nextcloud/l10n';
 import { generateUrl } from '@nextcloud/router';
 import { NcLoadingIcon, NcCheckboxRadioSwitch } from '@nextcloud/vue';
+import FilterIcon from 'vue-material-design-icons/Filter.vue';
+import FilterOutline from 'vue-material-design-icons/FilterOutline.vue';
+import __sfc_main$1 from './CnColumnFilterPopover.vue.js';
 import { useClickDragGuard } from '../../composables/useClickDragGuard.js';
+import { columnFilterDef, columnFilterState, isColumnFilterActive, columnFilterParams, clearedColumnFilterParams, isColumnSortable } from '../../utils/columnFilters.js';
 import { resolveHref, openRowTarget, followLinkClick } from '../../utils/linkNavigation.js';
 import { nextSortState } from '../../utils/multiColumnSort.js';
 import { preventMiddleClickAutoscroll, isRowMiddleClick, isNewTabHandled, markNewTabHandled, isNewTabClick } from '../../utils/rowAuxClick.js';
 import { DEFAULT_ROW_INDICATOR_CAP, resolveRowIndicators } from '../../utils/rowIndicators.js';
 import { columnsFromSchema } from '../../utils/schema.js';
 import __sfc_main from '../CnCellRenderer/CnCellRenderer.vue.js';
-import __sfc_main$1 from '../CnIcon/CnIcon.vue.js';
-import __sfc_main$2 from '../CnLockIndicator/CnLockIndicator.vue.js';
+import __sfc_main$2 from '../CnIcon/CnIcon.vue.js';
+import __sfc_main$3 from '../CnLockIndicator/CnLockIndicator.vue.js';
 
 /**
  * CnDataTable — Generic sortable data table for list views.
@@ -20,15 +24,12 @@ import __sfc_main$2 from '../CnLockIndicator/CnLockIndicator.vue.js';
  * row selection, custom cell rendering via scoped slots, loading states,
  * and empty states.
  *
- * Sorting: a plain click on a sortable header is single-sort (cycle asc →
- * desc → cleared), unchanged from before. Shift+click (or Shift+Enter on a
- * focused header) appends the column as a secondary/tertiary sort key —
- * capped at 3 — with numbered priority badges (1, 2, 3) once more than one
- * key is active. Pass `sortKeys: [{key, order}, ...]` for multi-sort (falls
- * back to the legacy `sortKey`/`sortOrder` props when empty). The `sort`
- * event payload is extended, not replaced: `{key, order}` still mirrors the
- * primary key exactly as before; a new `keys` field carries the full
- * ordered list. See `src/utils/multiColumnSort.js` for the state machine.
+ * Sorting: a plain click on a sortable header is single-sort (cycle asc → desc → cleared), unchanged from before.
+ * Shift+click (or Shift+Enter on a focused header) appends the column as a secondary/tertiary sort key, capped at 3, with numbered priority badges (1, 2, 3) once two or more rendered, sortable columns are sorted.
+ * A sort key whose column is not rendered, or not sortable, still sorts, but is not counted or numbered.
+ * Pass `sortKeys: [{key, order}, ...]` for multi-sort (falls back to the legacy `sortKey`/`sortOrder` props when empty).
+ * The `sort` event payload is extended, not replaced: `{key, order}` still mirrors the primary key exactly as before; a new `keys` field carries the full ordered list.
+ * See `src/utils/multiColumnSort.js` for the state machine.
  *
  * When a `schema` prop is provided, columns are auto-generated from schema
  * properties and cells render through CnCellRenderer for type-aware formatting
@@ -71,8 +72,11 @@ var script = {
 		NcLoadingIcon,
 		NcCheckboxRadioSwitch,
 		CnCellRenderer: __sfc_main,
-		CnIcon: __sfc_main$1,
-		CnLockIndicator: __sfc_main$2,
+		CnColumnFilterPopover: __sfc_main$1,
+		CnIcon: __sfc_main$2,
+		CnLockIndicator: __sfc_main$3,
+		FilterIcon,
+		FilterOutline,
 	},
 
 	inject: {
@@ -441,9 +445,39 @@ var script = {
 			type: Boolean,
 			default: false,
 		},
+
+		/**
+		 * Show a filter button in every header whose column can filter (see
+		 * `columnFilterDef`): enum, boolean, text, number, date and reference
+		 * columns backed by a schema property. A column opts out with
+		 * `filterable: false`. Applying a filter emits `column-filter`; the
+		 * host owns the filter state and passes it back as `activeFilters`.
+		 *
+		 * @spec openspec/changes/table-header-sort-and-filter/specs/cn-data-table/spec.md#requirement-every-backed-column-filters-from-its-header
+		 */
+		filterable: {
+			type: Boolean,
+			default: false,
+		},
+
+		/**
+		 * The active filter map, `{ paramKey: values[] }`: the same map the
+		 * facet sidebar writes, so a header filter and a sidebar filter on one
+		 * field show the same state.
+		 */
+		activeFilters: {
+			type: Object,
+			default: () => ({}),
+		},
+
+		/** Register slug a reference column's filter searches in when the column names none. */
+		filterRegister: {
+			type: String,
+			default: '',
+		},
 	},
 
-	emits: ['row-click', 'row-aux-click', 'row-context-menu', 'select', 'select-all', 'sort', 'view-all'],
+	emits: ['row-click', 'row-aux-click', 'row-context-menu', 'select', 'select-all', 'sort', 'view-all', 'column-filter'],
 
 	setup() {
 		// Tell a deliberate row click apart from a text-selection drag.
@@ -452,6 +486,10 @@ var script = {
 
 	data() {
 		return {
+			/** Key of the column whose filter panel is open, or ''. */
+			openFilterKey: '',
+			/** The open filter button's bounding rect, to place the panel. */
+			filterAnchorRect: null,
 			/**
 			 * Resolved aggregate-column values, keyed by `String(row[rowKey])`
 			 * then by column key. Populated by `loadAggregates()` for columns
@@ -569,8 +607,12 @@ var script = {
 						overrides: this.columnOverrides,
 					})
 				: this.columns;
+			// Every column backed by a schema property sorts unless it says
+			// `sortable: false`; object columns from a manifest used to need an
+			// explicit flag and so could not sort at all.
+			const withSort = (c) => (c && typeof c === 'object' ? { ...c, sortable: isColumnSortable(c, this.schema) } : c);
 			if (!(cols || []).some((c) => typeof c === 'string')) {
-				return cols || []
+				return (cols || []).map(withSort)
 			}
 			const schemaCols = this.schema
 				? columnsFromSchema(this.schema, { overrides: this.columnOverrides })
@@ -578,7 +620,7 @@ var script = {
 			const byKey = new Map(schemaCols.map((c) => [c.key, c]));
 			return (cols || []).map((c) => {
 				if (typeof c !== 'string') {
-					return c
+					return withSort(c)
 				}
 				return byKey.get(c) || { key: c, label: c, sortable: true }
 			})
@@ -619,6 +661,40 @@ var script = {
 			return links
 		},
 
+		/**
+		 * The column whose filter panel is open, or null.
+		 *
+		 * @return {object|null}
+		 */
+		openFilterColumn() {
+			if (!this.openFilterKey) {
+				return null
+			}
+			return this.effectiveColumns.find((c) => c && c.key === this.openFilterKey && this.filterDefFor(c)) || null
+		},
+
+		/**
+		 * One chip per column with an active header filter.
+		 *
+		 * @return {Array<{key: string, col: object, text: string, removeLabel: string}>}
+		 */
+		activeColumnFilterChips() {
+			if (!this.filterable) {
+				return []
+			}
+			return this.effectiveColumns
+				.filter((c) => c && this.isColumnFiltered(c))
+				.map((col) => {
+					const label = this.translateLabel(col.label);
+					const text = translate('nextcloud-vue', '{column}: {value}', { column: label, value: this.columnFilterSummary(col) });
+					return { key: col.key, col, text, removeLabel: translate('nextcloud-vue', 'Remove filter {column}', { column: label }) }
+				})
+		},
+
+		activeFiltersLabel() {
+			return translate('nextcloud-vue', 'Active filters')
+		},
+
 		effectiveSortKeys() {
 			if (this.sortKeys && this.sortKeys.length > 0) {
 				return this.sortKeys
@@ -629,6 +705,23 @@ var script = {
 			return []
 		},
 
+		/**
+		 * The active sort keys whose column renders a sort indicator, in priority order and deduplicated by first occurrence. Only these are counted and numbered by the priority badge.
+		 *
+		 * @return {Array<{key: string, order: 'asc'|'desc'}>}
+		 */
+		renderedSortKeys() {
+			const shown = new Set(this.effectiveColumns.filter((c) => c && c.sortable).map((c) => c.key));
+			const seen = new Set();
+			return this.effectiveSortKeys.filter((k) => {
+				if (!k || !shown.has(k.key) || seen.has(k.key)) {
+					return false
+				}
+				seen.add(k.key);
+				return true
+			})
+		},
+
 		totalColumns() {
 			let count = this.effectiveColumns.length;
 			if (this.selectable) {
@@ -1224,7 +1317,7 @@ var script = {
 
 		/**
 		 * Index of `key` within `effectiveSortKeys`, or -1 when not active.
-		 * Used by the template for the arrow, the numbered badge, and aria-sort.
+		 * Used by the template for the arrow.
 		 *
 		 * @param {string} key Column key.
 		 * @return {number}
@@ -1234,11 +1327,22 @@ var script = {
 		},
 
 		/**
-		 * `aria-sort` value for a column header: `'ascending'`/`'descending'`
-		 * for the PRIMARY (index 0) active sort key only — secondary/tertiary
-		 * keys carry the visible numbered badge instead, per WCAG guidance
-		 * that `aria-sort` describes single-column sort state. `null` omits
-		 * the attribute entirely (unsorted / not sortable).
+		 * The 1-based priority badge for `key` among the rendered sort keys, or null when fewer than two rendered columns are sorted or `key` is not one of them.
+		 *
+		 * @param {string} key Column key.
+		 * @return {number|null}
+		 */
+		sortBadgeFor(key) {
+			if (this.renderedSortKeys.length < 2) {
+				return null
+			}
+			const index = this.renderedSortKeys.findIndex((k) => k.key === key);
+			return index === -1 ? null : index + 1
+		},
+
+		/**
+		 * `aria-sort` value for a column header: `'ascending'`/`'descending'` for the PRIMARY (index 0) active sort key only, per WCAG guidance that `aria-sort` describes single-column sort state.
+		 * `null` omits the attribute entirely (unsorted, not sortable, or not the primary key).
 		 *
 		 * @param {object} col Column definition.
 		 * @return {string|null}
@@ -1262,6 +1366,135 @@ var script = {
 		 * @param {string} key Column key.
 		 * @param {MouseEvent} [event] The originating click event.
 		 */
+		/**
+		 * The filter definition for a column, or null when it does not filter
+		 * (header filters off, `filterable: false`, or nothing to filter on).
+		 *
+		 * @param {object} col The column.
+		 * @return {object|null}
+		 */
+		filterDefFor(col) {
+			if (!this.filterable || !col) {
+				return null
+			}
+			return columnFilterDef(col, this.schema)
+		},
+
+		columnFilterStateFor(col) {
+			return columnFilterState(this.filterDefFor(col), this.activeFilters)
+		},
+
+		isColumnFiltered(col) {
+			const def = this.filterDefFor(col);
+			return !!def && isColumnFilterActive(def, this.activeFilters)
+		},
+
+		filterButtonLabel(col) {
+			const column = this.translateLabel(col.label);
+			return this.isColumnFiltered(col)
+				? translate('nextcloud-vue', 'Filter {column}, active', { column })
+				: translate('nextcloud-vue', 'Filter {column}', { column })
+		},
+
+		/**
+		 * Short text for an active filter: the picked labels, or the range.
+		 *
+		 * @param {object} col The column.
+		 * @return {string}
+		 */
+		columnFilterSummary(col) {
+			const def = this.filterDefFor(col);
+			const state = this.columnFilterStateFor(col);
+			if (!def) {
+				return ''
+			}
+			if (def.kind === 'enum') {
+				const labels = Object.fromEntries((def.options || []).map((o) => [o.value, o.label]));
+				return state.values.map((v) => this.translateLabel(labels[v] || v)).join(', ')
+			}
+			if (def.kind === 'reference') {
+				return translatePlural('nextcloud-vue', '{count} selected', '{count} selected', state.values.length, { count: state.values.length })
+			}
+			if (def.kind === 'number' || def.kind === 'date') {
+				if (state.from && state.to) {
+					return translate('nextcloud-vue', '{from} to {to}', { from: state.from, to: state.to })
+				}
+				return state.from
+					? translate('nextcloud-vue', 'from {value}', { value: state.from })
+					: translate('nextcloud-vue', 'up to {value}', { value: state.to })
+			}
+			if (def.kind === 'boolean') {
+				return state.value === 'true' ? translate('nextcloud-vue', 'Yes') : translate('nextcloud-vue', 'No')
+			}
+			return state.value
+		},
+
+		/**
+		 * Open or close a column's filter panel under its button.
+		 *
+		 * @param {object} col The column.
+		 * @param {Event} event The click.
+		 * @return {void}
+		 */
+		toggleColumnFilter(col, event) {
+			if (this.openFilterKey === col.key) {
+				this.closeColumnFilter();
+				return
+			}
+			const target = event && event.currentTarget;
+			this.filterAnchorRect = target && typeof target.getBoundingClientRect === 'function'
+				? target.getBoundingClientRect()
+				: null;
+			this.openFilterKey = col.key;
+		},
+
+		/**
+		 * Close the open panel and give focus back to its button.
+		 *
+		 * @return {void}
+		 */
+		closeColumnFilter() {
+			const key = this.openFilterKey;
+			this.openFilterKey = '';
+			if (!key) {
+				return
+			}
+			this.$nextTick(() => {
+				const ref = this.$refs['filterButton-' + key];
+				const button = Array.isArray(ref) ? ref[0] : ref;
+				if (button && typeof button.focus === 'function') {
+					button.focus();
+				}
+			});
+		},
+
+		/**
+		 * Apply a panel's state: emit the query parameters it stands for.
+		 *
+		 * @param {object} col The column.
+		 * @param {object} state The panel state.
+		 * @return {void}
+		 * @spec openspec/changes/table-header-sort-and-filter/specs/cn-data-table/spec.md#requirement-a-header-filter-speaks-the-sidebars-query-language
+		 */
+		applyColumnFilter(col, state) {
+			const def = this.filterDefFor(col);
+			if (def) {
+				/**
+				 * @event column-filter A header filter was applied or cleared.
+				 * @type {{ key: string, params: object }} `params` maps each query parameter the column owns to its values; an empty list clears it.
+				 */
+				this.$emit('column-filter', { key: col.key, params: columnFilterParams(def, state) });
+			}
+			this.closeColumnFilter();
+		},
+
+		clearColumnFilter(col) {
+			const def = this.filterDefFor(col);
+			if (def) {
+				this.$emit('column-filter', { key: col.key, params: clearedColumnFilterParams(def) });
+			}
+		},
+
 		onHeaderClick(key, event) {
 			this.applySort(key, !!(event && event.shiftKey));
 		},