@mono-lit/helper 0.0.8 → 0.0.10

package/dist/{mono-data-chart-NKPdAgVq.js → mono-data-chart-ChF4J9RT.js}

@@ -1,9 +1,9 @@
-import { n as isPath, t as getFieldValue } from "./field-path-BabiMrrA.js";
-import { r as readAllRows } from "./data-source-read-BL266IW0.js";
-import { n as andPredicates, r as compileFilterPredicate, t as andFilters } from "./filter-eval-ChDSaAUH.js";
-import { n as describeError, o as isCanceled } from "./normalize-error-D93O4q8g.js";
-import { a as resolveDataSourceOptions, d as createApplyGate, f as isRolledUp, h as monoArraySource, i as normalizeSortList, n as extraLoadOptions, o as toList, p as loadApply, r as mergeDataSourceOptions, u as summaryFilterOf } from "./data-source-options-fxT5QIX4.js";
-import { t as arrayToODataString } from "./filter-odata-Bi27XUpQ.js";
+import { n as isPath, t as getFieldValue } from "./field-path-DK2VBWHl.js";
+import { r as readAllRows } from "./data-source-read-uKJpRAzx.js";
+import { n as andPredicates, r as compileFilterPredicate, t as andFilters } from "./filter-eval-CqeBnMYh.js";
+import { n as describeError, o as isCanceled } from "./normalize-error-BEcd1tmS.js";
+import { _ as monoArraySource, a as resolveDataSourceOptions, d as createApplyGate, f as isRolledUp, i as normalizeSortList, n as extraLoadOptions, o as toList, p as loadApply, r as mergeDataSourceOptions, u as summaryFilterOf } from "./data-source-options-DJUNU26C.js";
+import { t as arrayToODataString } from "./filter-odata-GsczYKNC.js";
 import { t as createNotifier } from "./notifier-BIrqUzRh.js";
 
 //#region src/components/chart/chart-odata.ts

package/dist/{mono-data-dropdown-DUXo_jxd.js → mono-data-dropdown-Bgj2PDfm.js}

@@ -1,4 +1,4 @@
-import { t as monoDataGrid } from "./mono-data-grid-Bb00QM72.js";
+import { t as monoDataGrid } from "./mono-data-grid-DJkp96N-.js";
 import { t as createNotifier } from "./notifier-BIrqUzRh.js";
 
 //#region src/components/dropdown-table/mono-data-dropdown.ts

package/dist/{mono-data-grid-Bb00QM72.js → mono-data-grid-DJkp96N-.js}

@@ -1,12 +1,12 @@
-import { a as parseFieldPath, c as toODataClause, l as toODataSelector, n as isPath, o as projectFields, r as mergePatch, s as setFieldValue, t as getFieldValue } from "./field-path-BabiMrrA.js";
-import { a as buildGroups, c as isGroupNode, i as searchFilterOf, o as collectGroupPaths, r as readAllRows, s as flattenLeaves } from "./data-source-read-BL266IW0.js";
-import { i as joinFilters, n as andPredicates, r as compileFilterPredicate, t as andFilters } from "./filter-eval-ChDSaAUH.js";
-import { A as resolveSearchEntries, C as customRemoteClause, E as hasWildcardSearch, S as customPredicate, T as hasCustomSearch, h as mergeSearchFields, j as searchEntryFor, k as plainSearchColumns, n as describeError, o as isCanceled, u as DEFAULT_SEARCH_FIELDS } from "./normalize-error-D93O4q8g.js";
-import { a as resolveDataSourceOptions, c as composeSummaryApply, d as createApplyGate, f as isRolledUp, h as monoArraySource, i as normalizeSortList, l as summaryAliases, m as storeRows, n as extraLoadOptions, o as toList, p as loadApply, s as buildSummaryApply, t as dataSourceOptionsKey, u as summaryFilterOf } from "./data-source-options-fxT5QIX4.js";
+import { a as parseFieldPath, c as toODataClause, l as toODataSelector, n as isPath, o as projectFields, r as mergePatch, s as setFieldValue, t as getFieldValue } from "./field-path-DK2VBWHl.js";
+import { a as buildGroups, c as isGroupNode, i as searchFilterOf, o as collectGroupPaths, r as readAllRows, s as flattenLeaves } from "./data-source-read-uKJpRAzx.js";
+import { i as joinFilters, n as andPredicates, r as compileFilterPredicate, t as andFilters } from "./filter-eval-CqeBnMYh.js";
+import { A as resolveSearchEntries, C as customRemoteClause, E as hasWildcardSearch, S as customPredicate, T as hasCustomSearch, h as mergeSearchFields, j as searchEntryFor, k as plainSearchColumns, n as describeError, o as isCanceled, u as DEFAULT_SEARCH_FIELDS } from "./normalize-error-BEcd1tmS.js";
+import { _ as monoArraySource, a as resolveDataSourceOptions, c as composeSummaryApply, d as createApplyGate, f as isRolledUp, g as storeRows, i as normalizeSortList, l as summaryAliases, n as extraLoadOptions, o as toList, p as loadApply, s as buildSummaryApply, t as dataSourceOptionsKey, u as summaryFilterOf } from "./data-source-options-DJUNU26C.js";
 import { n as unwrapReactive } from "./reactive-Dtd-esHO.js";
-import { t as arrayToODataString } from "./filter-odata-Bi27XUpQ.js";
+import { t as arrayToODataString } from "./filter-odata-GsczYKNC.js";
 import { t as createNotifier } from "./notifier-BIrqUzRh.js";
-import { t as monoFilterBuilder } from "./filter-builder-C0T3pMx2.js";
+import { t as monoFilterBuilder } from "./filter-builder-vbqIuPhX.js";
 
 //#region src/components/table/store-group-source.ts
 /**
@@ -377,6 +377,114 @@ function inRange(d, r) {
 	return t >= r.from.getTime() && t < r.to.getTime();
 }
 
+//#endregion
+//#region src/utils/group-count.ts
+/**
+* Per-value row counts for ONE field, as `{ value, count }` rows.
+*
+* Two consumers share this: the grid's header filter (`distinctValues`) and the
+* table search's filter suggestion (`components/table/filter-suggestion.ts`),
+* which asks "how many rows match this search under each OTHER value of Dept".
+*
+* Remote: one `$apply=filter(…)/groupby((field),aggregate($count as count))`
+* through the store (see `data-source-apply.ts` for why it rides `urlOverride`).
+* Array: a plain tally over the rows.
+*/
+/**
+* Group-count `field` through `store` with ONE `$apply`, or `null` when that path
+* is not available — the gate is off, a wildcard path (nothing to group by), a
+* store that cannot carry an `$apply` (a CustomStore), a failed request (reported
+* to the gate), or a response that is not rolled up (a server that ignored the
+* clause). An EMPTY grouped result is a real answer and comes back as `[]`.
+*
+* The rows are returned in server order — the caller sorts.
+*/
+async function groupCountViaApply(store, field, filter, gate, options = {}) {
+	const rows = await groupCountsViaApply(store, [field], filter, gate, options);
+	return rows ? rows.map((r) => ({
+		value: r.values[field],
+		count: r.count
+	})) : null;
+}
+/**
+* {@link groupCountViaApply} over SEVERAL fields at once — one
+* `groupby((A,B),aggregate($count as count))` request, one row per combination
+* that exists. Same `null` contract.
+*/
+async function groupCountsViaApply(store, fields, filter, gate, options = {}) {
+	if (gate.skip || !fields.length) return null;
+	const selectors = [];
+	for (const field of fields) {
+		if (parseFieldPath(field).hasWildcard) return null;
+		const selector = isPath(field) ? toODataSelector(field) : field;
+		if (!selector) return null;
+		selectors.push(selector);
+	}
+	const apply = `groupby((${selectors.join(",")}),aggregate($count as count))`;
+	const odataFilter = filter != null ? arrayToODataString(filter) : "";
+	const clause = odataFilter ? `filter(${odataFilter})/${apply}` : apply;
+	const top = typeof options.top === "number" && options.top >= 0 ? options.top : void 0;
+	let rows;
+	try {
+		rows = await loadApply(store, clause, { top });
+	} catch (err) {
+		gate.reject(err);
+		return null;
+	}
+	if (!rows) return null;
+	if (!rows.length) return [];
+	const first = rows[0];
+	if (!first || typeof first !== "object" || !isCount(first.count)) return null;
+	if (!isRolledUp(rows, [...fields, "count"])) return null;
+	return rows.map((r) => ({
+		values: pickValues(r, fields),
+		count: Number(r.count) || 0
+	}));
+}
+/** Each field's value off a row, path-aware. */
+function pickValues(row, fields) {
+	const out = {};
+	for (const f of fields) out[f] = isPath(f) ? getFieldValue(row, f) : row?.[f];
+	return out;
+}
+/** {@link countValues} over several fields: one tuple per combination, with its row count. */
+function countTuples(rows, fields) {
+	const by = /* @__PURE__ */ new Map();
+	for (const r of rows) {
+		const values = pickValues(r, fields);
+		const key = JSON.stringify(fields.map((f) => values[f] ?? null));
+		const hit = by.get(key);
+		if (hit) hit.count++;
+		else by.set(key, {
+			values,
+			count: 1
+		});
+	}
+	return [...by.values()];
+}
+/** A number, or a string that is one (`"12"`). */
+function isCount(v) {
+	if (typeof v === "number") return Number.isFinite(v);
+	return typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v));
+}
+/** Count occurrences of `field` across `rows` (path-aware; a wildcard path flattens). */
+function countValues(rows, field) {
+	const counts = /* @__PURE__ */ new Map();
+	const bump = (v) => {
+		counts.set(v, (counts.get(v) ?? 0) + 1);
+	};
+	const path = isPath(field);
+	for (const r of rows) if (path) {
+		const v = getFieldValue(r, field);
+		if (Array.isArray(v)) v.forEach(bump);
+		else bump(v);
+	} else bump(r?.[field]);
+	return [...counts.entries()].map(([value, count]) => ({
+		value,
+		count
+	}));
+}
+
 //#endregion
 //#region src/components/table/mono-data-grid.ts
 function monoDataGrid(ds = null, opts = {}) {
@@ -445,6 +553,9 @@ function monoDataGrid(ds = null, opts = {}) {
 	const chunkSize = Math.max(1, opts.chunkSize ?? 100);
 	let suppressSync = false;
 	let allRows = [];
+	let browserRows = null;
+	let browserPageIndex = 0;
+	let browserPageSize = 0;
 	let scrollMode = "off";
 	let accumulated = [];
 	let scrollNextPage = 0;
@@ -504,6 +615,9 @@ function monoDataGrid(ds = null, opts = {}) {
 		pageSizeAll: false,
 		pageCount: 0,
 		searchTerms: [],
+		filterSuggestion: null,
+		filterSuggestions: [],
+		setFilterSuggestion,
 		sorts: [],
 		sortField: null,
 		sortOrder: null,
@@ -2148,16 +2262,21 @@ function monoDataGrid(ds = null, opts = {}) {
 	* column sort follows — applied to the group field itself if it is one.
 	*/
 	function effectiveSort() {
-		const keys = ctrl.sorts.map((s) => ({
-			selector: s.field,
+		const keys = ctrl.sorts.filter((s) => !isBrowserSortKey(s.field)).map((s) => ({
+			field: s.field,
+			selector: declaredSortSelector(s.field) ?? s.field,
 			desc: s.order === "desc"
 		}));
-		if (!groupFields.length) return keys.length ? keys : null;
+		const entry = (k) => ({
+			selector: k.selector,
+			desc: k.desc
+		});
+		if (!groupFields.length) return keys.length ? keys.map(entry) : null;
 		const list = groupFields.map((f) => ({
 			selector: f,
-			desc: keys.find((k) => k.selector === f)?.desc ?? false
+			desc: keys.find((k) => k.field === f)?.desc ?? false
 		}));
-		for (const k of keys) if (!groupFields.includes(k.selector)) list.push(k);
+		for (const k of keys) if (!groupFields.includes(k.field)) list.push(entry(k));
 		return list;
 	}
 	/**
@@ -2572,6 +2691,10 @@ function monoDataGrid(ds = null, opts = {}) {
 			syncScroll();
 			return;
 		}
+		if (browserRows && browserSortActive()) {
+			syncBrowser();
+			return;
+		}
 		if (pageSizeAll) {
 			ctrl.grouped = false;
 			ctrl.items = allRows;
@@ -2735,6 +2858,11 @@ function monoDataGrid(ds = null, opts = {}) {
 			await loadScrollPage(true);
 			return;
 		}
+		if (browserSortActive()) {
+			await loadBrowserSorted();
+			return;
+		}
+		browserRows = null;
 		if (pageSizeAll && !isGrouped()) {
 			await loadAllChunked();
 			return;
@@ -2756,6 +2884,11 @@ function monoDataGrid(ds = null, opts = {}) {
 			await loadScrollPage(true);
 			return;
 		}
+		if (browserSortActive()) {
+			await loadBrowserSorted();
+			return;
+		}
+		browserRows = null;
 		if (pageSizeAll && !isGrouped()) {
 			await loadAllChunked();
 			return;
@@ -2792,6 +2925,11 @@ function monoDataGrid(ds = null, opts = {}) {
 			if (serverMode()) await fetchVisibleRows();
 			return;
 		}
+		if (browserRows && browserSortActive()) {
+			browserPageIndex = Math.max(0, pageIndex);
+			syncBrowser();
+			return;
+		}
 		const s = bound;
 		if (!s) return;
 		s.pageIndex?.(Math.max(0, pageIndex));
@@ -2809,6 +2947,15 @@ function monoDataGrid(ds = null, opts = {}) {
 		}
 		const s = bound;
 		if (!s) return;
+		if (browserRows && browserSortActive()) {
+			if (!all) {
+				browserPageSize = Math.max(1, pageSize);
+				s.pageSize?.(browserPageSize);
+			}
+			browserPageIndex = 0;
+			syncBrowser();
+			return;
+		}
 		if (all) {
 			await loadAllChunked();
 			return;
@@ -2855,6 +3002,127 @@ function monoDataGrid(ds = null, opts = {}) {
 		ctrl.loading = bound?.isLoading?.() ?? false;
 		sync();
 	}
+	const BROWSER_SORT_MAX_ROWS = 5e3;
+	/** The active sort keys when ANY of them sorts in the browser, else `null`. */
+	function browserSortKeys() {
+		if (!ctrl.sorts.some((s) => isBrowserSortKey(s.field))) return null;
+		return ctrl.sorts.map((s) => {
+			const browser = isBrowserSortKey(s.field);
+			return {
+				field: s.field,
+				selector: declaredSortSelector(s.field) ?? s.field,
+				desc: s.order === "desc",
+				aggregate: browser ? declaredSortConfig(s.field).aggregate ?? "sum" : null
+			};
+		});
+	}
+	/** Browser sort applies: a browser-sorted column is active on a flat, paged, bound table. */
+	function browserSortActive() {
+		return !!bound && !isGrouped() && !serverMode() && !scrollActive() && !!browserSortKeys();
+	}
+	/** The smallest `maxRows` any active browser-sorted column declares (default 5000). */
+	function browserSortCap() {
+		const caps = ctrl.sorts.filter((s) => isBrowserSortKey(s.field)).map((s) => Number(declaredSortConfig(s.field).maxRows)).filter((n) => Number.isFinite(n) && n > 0);
+		return caps.length ? Math.min(...caps) : BROWSER_SORT_MAX_ROWS;
+	}
+	/** A row's matches for `selector` reduced to one sortable value. */
+	function browserSortValue(row, selector, aggregate) {
+		const raw = getFieldValue(row, selector);
+		if (!aggregate) return raw;
+		const list = Array.isArray(raw) ? raw : raw == null ? [] : [raw];
+		if (aggregate === "count") return list.length;
+		const nums = list.map(Number).filter((n) => Number.isFinite(n));
+		if (!nums.length) return aggregate === "sum" ? 0 : null;
+		if (aggregate === "min") return Math.min(...nums);
+		if (aggregate === "max") return Math.max(...nums);
+		const sum = nums.reduce((a, b) => a + b, 0);
+		return aggregate === "avg" ? sum / nums.length : sum;
+	}
+	/** Empties last in either direction; numbers numerically; text numeric-aware. */
+	function compareBrowserValues(a, b) {
+		const ea = a == null || a === "";
+		const eb = b == null || b === "";
+		if (ea || eb) return ea === eb ? 0 : ea ? 1 : -1;
+		if (typeof a === "number" && typeof b === "number") return a - b;
+		if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
+		return String(a).localeCompare(String(b), void 0, { numeric: true });
+	}
+	/** Every matching row, sorted by the active keys (stable). */
+	function sortBrowserRows(rows) {
+		const keys = browserSortKeys() ?? [];
+		const decorated = rows.map((row, i) => ({
+			row,
+			i,
+			v: keys.map((k) => browserSortValue(row, k.selector, k.aggregate))
+		}));
+		decorated.sort((x, y) => {
+			for (let k = 0; k < keys.length; k++) {
+				const ex = x.v[k] == null || x.v[k] === "";
+				const ey = y.v[k] == null || y.v[k] === "";
+				const c = compareBrowserValues(x.v[k], y.v[k]);
+				if (c) return ex || ey ? c : keys[k].desc ? -c : c;
+			}
+			return x.i - y.i;
+		});
+		return decorated.map((d) => d.row);
+	}
+	/** Too many rows to sort in the browser: drop those keys, warn, load normally. */
+	async function refuseBrowserSort(count, cap) {
+		const fields = ctrl.sorts.filter((s) => isBrowserSortKey(s.field)).map((s) => s.field);
+		console.warn(`[monoDataGrid] sort: "${fields.join("\", \"")}" sorts in the browser and needs every row, but ${count} match (maxRows ${cap}) — sort cleared.`);
+		ctrl.sorts = ctrl.sorts.filter((s) => !isBrowserSortKey(s.field));
+		syncPrimarySort();
+		browserRows = null;
+		applySourceSort();
+		notify();
+		await load();
+	}
+	/** Read every matching row, sort it in memory, show the first page. */
+	async function loadBrowserSorted() {
+		const s = bound;
+		if (!s) return;
+		const cap = browserSortCap();
+		const known = s.totalCount?.();
+		if (typeof known === "number" && known > cap) {
+			await refuseBrowserSort(known, cap);
+			return;
+		}
+		if (!browserPageSize) browserPageSize = Math.max(1, s.pageSize?.() || ctrl.pageSize || 20);
+		ctrl.loading = true;
+		notify();
+		let rows = [];
+		try {
+			await runLoad(async () => {
+				rows = await readAllFromSource();
+			});
+		} finally {
+			ctrl.loading = false;
+		}
+		if (rows.length > cap) {
+			await refuseBrowserSort(rows.length, cap);
+			return;
+		}
+		browserRows = sortBrowserRows(rows);
+		browserPageIndex = 0;
+		sync();
+		recomputeSummaries();
+	}
+	/** Map the in-memory sorted rows (current page, or all) onto `ctrl`. */
+	function syncBrowser() {
+		const rows = browserRows ?? [];
+		const size = pageSizeAll ? Math.max(1, rows.length) : Math.max(1, browserPageSize);
+		const pageCount = Math.max(1, Math.ceil(rows.length / size));
+		browserPageIndex = Math.min(Math.max(0, browserPageIndex), pageCount - 1);
+		const start = browserPageIndex * size;
+		ctrl.grouped = false;
+		ctrl.items = rows.slice(start, start + size);
+		ctrl.pageIndex = browserPageIndex;
+		ctrl.pageSize = size;
+		ctrl.pageSizeAll = pageSizeAll;
+		ctrl.totalCount = rows.length;
+		ctrl.pageCount = pageCount;
+		render();
+	}
 	/** Scroll modes only apply to a flat (ungrouped, non-server) grid. */
 	function scrollActive() {
 		return scrollMode !== "off" && !isGrouped() && !serverMode();
@@ -3192,8 +3460,30 @@ function monoDataGrid(ds = null, opts = {}) {
 		}
 		await setSearchTerms(ctrl.searchTerms);
 	}
+	/** What identifies an offer for the change check — a re-published identical list is a no-op. */
+	const offerKey = (list) => {
+		try {
+			return JSON.stringify(list.map((s) => [
+				s.key,
+				s.count,
+				s.values
+			]));
+		} catch {
+			return String(Math.random());
+		}
+	};
+	/** Equality-guarded so a re-published identical list costs no notify (no re-render loop). */
+	function setFilterSuggestion(next) {
+		const list = next == null ? [] : Array.isArray(next) ? next.filter(Boolean) : [next];
+		if (offerKey(list) === offerKey(ctrl.filterSuggestions)) return;
+		ctrl.filterSuggestions = list;
+		ctrl.filterSuggestion = list[0] ?? null;
+		notify();
+	}
 	async function setSearchTerms(terms) {
 		ctrl.searchTerms = (terms ?? []).filter((t) => t && String(t.value ?? "") !== "");
+		ctrl.filterSuggestion = null;
+		ctrl.filterSuggestions = [];
 		groupPageIndex = 0;
 		bumpSummary("search");
 		if (serverMode()) {
@@ -3633,48 +3923,13 @@ function monoDataGrid(ds = null, opts = {}) {
 	* exactly as every other request does.
 	*/
 	async function distinctViaApply(store, field, options) {
-		if (applyGate.skip) return null;
-		if (parseFieldPath(field).hasWildcard) return null;
-		const selector = isPath(field) ? toODataSelector(field) : field;
-		if (!selector) return null;
-		const apply = `groupby((${selector}),aggregate($count as count))`;
-		const odataFilter = options?.filter != null ? arrayToODataString(options.filter) : "";
-		const clause = odataFilter ? `filter(${odataFilter})/${apply}` : apply;
 		const top = typeof options?.take === "number" && options.take >= 0 ? options.take : void 0;
-		let rows;
-		try {
-			rows = await loadApply(store, clause, { top });
-		} catch (err) {
-			applyGate.reject(err);
-			return null;
-		}
-		if (!rows) return null;
-		if (!rows.length) return [];
-		const first = rows[0];
-		if (!first || typeof first !== "object" || typeof first.count !== "number") return null;
-		if (!isRolledUp(rows, [field, "count"])) return null;
-		const path = isPath(field);
-		return sortColumnValues(rows.map((r) => ({
-			value: path ? getFieldValue(r, field) : r[field],
-			count: Number(r.count) || 0
-		})));
+		const rows = await groupCountViaApply(store, field, options?.filter ?? null, applyGate, { top });
+		return rows ? sortColumnValues(rows) : null;
 	}
 	/** Count occurrences of `field` across `rows` into a sorted `{value,count}[]`. */
 	function distinctFromRows(rows, field) {
-		const counts = /* @__PURE__ */ new Map();
-		const bump = (v) => {
-			counts.set(v, (counts.get(v) ?? 0) + 1);
-		};
-		const path = isPath(field);
-		for (const r of rows) if (path) {
-			const v = getFieldValue(r, field);
-			if (Array.isArray(v)) v.forEach(bump);
-			else bump(v);
-		} else bump(r?.[field]);
-		return sortColumnValues([...counts.entries()].map(([value, count]) => ({
-			value,
-			count
-		})));
+		return sortColumnValues(countValues(rows, field));
 	}
 	async function distinctValues(field, options) {
 		if (!field) return [];
@@ -3787,6 +4042,41 @@ function monoDataGrid(ds = null, opts = {}) {
 		});
 		ctrl.sorts = marked.map((m) => m.s);
 	}
+	/**
+	* The source selector a column DECLARED via `sort.selector`, if any — what the
+	* DataSource / array source orders by in place of the field. Resolved like
+	* `declaredSortIndex`: central `props.th` config first, then the element's own
+	* `:sort.prop`. A blank string counts as not declared.
+	*/
+	function declaredSortSelector(field) {
+		const sel = declaredSortConfig(field).selector;
+		return typeof sel === "string" && sel.trim() ? sel.trim() : void 0;
+	}
+	/**
+	* A column's declared sort OBJECT — the element's `:sort.prop` with central
+	* `props.th` config merged over it (props win key by key, as everywhere). `{}`
+	* for `sort: true` / no config.
+	*/
+	function declaredSortConfig(field) {
+		const asObj = (sort) => typeof sort === "object" && sort ? sort : {};
+		let fromEl = {};
+		for (const el of columnEls) if (el.field === field && typeof el.sort === "object" && el.sort) {
+			fromEl = asObj(el.sort);
+			break;
+		}
+		return {
+			...fromEl,
+			...asObj((elementProps.th ?? []).find((c) => c?.field === field)?.sort)
+		};
+	}
+	/**
+	* Whether a sorted column is sorted IN THE BROWSER — its selector fans out over a
+	* collection (`[*]`, which no source can order by) or it declares an `aggregate`.
+	*/
+	function isBrowserSortKey(field) {
+		const sel = declaredSortSelector(field);
+		return !!sel && parseFieldPath(sel).hasWildcard || !!declaredSortConfig(field).aggregate;
+	}
 	/** Keep the single-value mirrors pointing at the primary key. */
 	function syncPrimarySort() {
 		ctrl.sortField = ctrl.sorts[0]?.field ?? null;
@@ -3975,6 +4265,11 @@ function monoDataGrid(ds = null, opts = {}) {
 	* see the intermediate full-list state.
 	*/
 	async function getData() {
+		if (browserRows && browserSortActive()) return [...browserRows];
+		return readAllFromSource();
+	}
+	/** `getData`'s read — every matching row from the source, in its own order. */
+	async function readAllFromSource() {
 		const s = bound;
 		if (!s) return [];
 		const loadOptions = {};
@@ -4041,4 +4336,4 @@ function monoDataGrid(ds = null, opts = {}) {
 }
 
 //#endregion
-export { seedFromRanges as a, minimize as i, buildDateTree as n, setAllChecked as o, checkState as r, setChecked as s, monoDataGrid as t };
+export { checkState as a, setAllChecked as c, buildDateTree as i, setChecked as l, countTuples as n, minimize as o, groupCountsViaApply as r, seedFromRanges as s, monoDataGrid as t };

package/dist/{mono-event-BPku9HpS.js → mono-event-CAZf0F_k.js}

@@ -99,31 +99,36 @@ function decorateEvent(event, detail) {
 *   dispatchMonoEvent(this, 'loading-change', detail)                  // loading-change + loadingChange + mno-loading-change + mnoLoadingChange
 */
 function dispatchMonoEvent(target, name, detail, options = {}) {
+	const cancelable = !!options.cancelable;
 	const init = {
 		detail,
 		bubbles: true,
-		composed: true
+		composed: true,
+		cancelable
 	};
+	let allowed = true;
 	const camel = toCamelEventName(`mno-${name}`);
-	target.dispatchEvent(new CustomEvent(`mno-${name}`, init));
-	target.dispatchEvent(new CustomEvent(camel, init));
+	allowed = target.dispatchEvent(new CustomEvent(`mno-${name}`, init)) && allowed;
+	allowed = target.dispatchEvent(new CustomEvent(camel, init)) && allowed;
 	const alias = options.alias === false ? null : options.alias ?? name;
-	if (!alias) return;
+	if (!alias) return allowed;
 	const fromDetail = detail?.sourceEvent;
 	const source = options.sourceEvent !== void 0 ? options.sourceEvent : fromDetail instanceof Event ? fromDetail : null;
 	if (source && source.type === alias && reachesHost(source, target)) {
 		decorateEvent(source, detail);
-		return;
+		return allowed;
 	}
-	if (MONO_DEVICE_EVENTS.has(alias)) return;
+	if (MONO_DEVICE_EVENTS.has(alias)) return allowed;
 	const plainInit = {
 		detail,
 		bubbles: !MONO_NON_BUBBLING_ALIASES.has(alias),
-		composed: true
+		composed: true,
+		cancelable
 	};
-	target.dispatchEvent(new CustomEvent(alias, plainInit));
+	allowed = target.dispatchEvent(new CustomEvent(alias, plainInit)) && allowed;
 	const plainCamel = toCamelEventName(alias);
-	if (plainCamel !== alias) target.dispatchEvent(new CustomEvent(plainCamel, plainInit));
+	if (plainCamel !== alias) allowed = target.dispatchEvent(new CustomEvent(plainCamel, plainInit)) && allowed;
+	return allowed;
 }
 
 //#endregion

package/dist/{mono-form-controller-BrA10erm.js → mono-form-controller-DxZLvyg6.js}

@@ -430,7 +430,8 @@ function monoForm(options) {
 		_register,
 		_report,
 		_reportList,
-		_propsFor: propsFor
+		_propsFor: propsFor,
+		_elements: (key) => [...elements[key] ?? []]
 	};
 }