@atscript/vue-table 0.1.140 → 0.1.142

package/dist/{use-table-column-handlers-rqFo9HLz.cjs → use-table-column-handlers-BHMCo_HR.cjs}

@@ -1,4 +1,4 @@
-const require_use_table_state = require("./use-table-state-pF_9gnTG.cjs");
+const require_use_table_state = require("./use-table-state-BiklfjP0.cjs");
 let vue = require("vue");
 let _atscript_ui_table = require("@atscript/ui-table");
 //#region src/composables/use-row-actions-column.ts

package/dist/{use-table-component-XQ-Qt_sp.cjs → use-table-component-IziAm0vk.cjs}

@@ -1,4 +1,4 @@
-const require_use_table_state = require("./use-table-state-pF_9gnTG.cjs");
+const require_use_table_state = require("./use-table-state-BiklfjP0.cjs");
 //#region src/composables/use-table-component.ts
 /**
 * Resolve a single skin-slot component from the injected `controls` map,

package/dist/{use-table-component-BYO0zMQj.mjs → use-table-component-TLwFq4rx.mjs}

@@ -1,4 +1,4 @@
-import { o as useTableContextOptional } from "./use-table-state-BzjbnpBA.mjs";
+import { o as useTableContextOptional } from "./use-table-state-Cq-3tbVr.mjs";
 //#region src/composables/use-table-component.ts
 /**
 * Resolve a single skin-slot component from the injected `controls` map,

package/dist/{use-table-nav-bridge-BDBnRc4C.mjs → use-table-nav-bridge-CkQqimdS.mjs}

@@ -1,4 +1,4 @@
-import { o as useTableContextOptional } from "./use-table-state-BzjbnpBA.mjs";
+import { o as useTableContextOptional } from "./use-table-state-Cq-3tbVr.mjs";
 //#region src/composables/use-table-nav-bridge.ts
 function isPassthroughKey(event) {
 	const key = event.key;

package/dist/{use-table-nav-bridge-DvrsPanF.cjs → use-table-nav-bridge-QU4jKhqx.cjs}

@@ -1,4 +1,4 @@
-const require_use_table_state = require("./use-table-state-pF_9gnTG.cjs");
+const require_use_table_state = require("./use-table-state-BiklfjP0.cjs");
 //#region src/composables/use-table-nav-bridge.ts
 function isPassthroughKey(event) {
 	const key = event.key;

package/dist/{use-table-state-pF_9gnTG.cjs → use-table-state-BiklfjP0.cjs}

@@ -565,6 +565,14 @@ function buildRemoveAction(opts) {
 /** Shared verdicts — frozen, so the common case allocates nothing per row. */
 const SELECTABLE = Object.freeze({ ok: true });
 const NOT_SELECTABLE = Object.freeze({ ok: false });
+/**
+* The header tri-state from how many of the rows in scope are eligible and
+* how many of those are selected.
+*/
+function toSelectAllState(selected, selectable) {
+	if (selected === 0) return "none";
+	return selected >= selectable ? "all" : "some";
+}
 /** Normalise a {@link RowSelectableHook} return value. `""` carries no reason. */
 function verdictOf(value) {
 	if (value === void 0 || value === true) return SELECTABLE;
@@ -602,22 +610,33 @@ function createSelectionApi(opts, getActiveRow, activeIndex) {
 		for (let i = 0; i < rows.length; i++) if (isRowSelectable(rows[i], i).ok) n++;
 		return n;
 	}
+	function eligiblePks(rows) {
+		return (0, _atscript_ui_table.rowsToPks)(selectableRows(rows), rowValueFn);
+	}
+	function addPks(pks) {
+		const current = selectedSet.value;
+		const added = [...new Set(pks)].filter((pk) => !current.has(pk));
+		if (added.length > 0) selectedRows.value = [...selectedRows.value, ...added];
+	}
+	function removePks(pks) {
+		const drop = new Set(pks);
+		const next = selectedRows.value.filter((pk) => !drop.has(pk));
+		if (next.length !== selectedRows.value.length) selectedRows.value = next;
+	}
 	function selectAll(rows, indexOf) {
-		if (!rowSelectable.value) {
-			selectedRows.value = (0, _atscript_ui_table.rowsToPks)(rows, rowValueFn);
-			return;
-		}
-		const out = [];
-		const seen = /* @__PURE__ */ new Set();
-		for (let i = 0; i < rows.length; i++) {
-			const row = rows[i];
-			const pk = rowValueFn(row);
-			if (seen.has(pk)) continue;
-			if (!isRowSelectable(row, indexOf ? indexOf(i) : i).ok && !isPkSelected(pk)) continue;
-			seen.add(pk);
-			out.push(pk);
-		}
-		selectedRows.value = out;
+		addPks((0, _atscript_ui_table.rowsToPks)(indexOf ? rows.filter((row, i) => isRowSelectable(row, indexOf(i)).ok) : selectableRows(rows), rowValueFn));
+	}
+	function deselectAll(rows) {
+		removePks(eligiblePks(rows));
+	}
+	function toggleAll(rows) {
+		const pks = eligiblePks(rows);
+		const selected = pks.filter((pk) => selectedSet.value.has(pk)).length;
+		if (toSelectAllState(selected, pks.length) === "all") removePks(pks);
+		else addPks(pks);
+	}
+	function clearSelection() {
+		if (selectedRows.value.length > 0) selectedRows.value = [];
 	}
 	function toggleActiveSelection(mode) {
 		if (mode === "none") return;
@@ -637,6 +656,9 @@ function createSelectionApi(opts, getActiveRow, activeIndex) {
 		selectableRows,
 		selectableCount,
 		selectAll,
+		deselectAll,
+		toggleAll,
+		clearSelection,
 		toggleActiveSelection
 	};
 }
@@ -854,6 +876,15 @@ function createNavController(inputs) {
 	};
 }
 /**
+* Toggle the row at `index`: it becomes the active row, then the active row
+* toggles. Selectability is NOT re-checked here: `toggleActiveSelection`
+* gates on `rowSelectable` itself, which is the single place that rule lives.
+*/
+function toggleRowAt(index, mode, state) {
+	state.setActive(index);
+	state.toggleActiveSelection(mode);
+}
+/**
 * `@keydown` handler for a row's SELECTION CONTROL (the leading checkbox),
 * shared by `<AsTableBase>` and `<AsWindowTableBase>`. The control carries
 * `role="checkbox"`, so the tbody-level nav handler deliberately leaves
@@ -862,16 +893,13 @@ function createNavController(inputs) {
 * Keys other than Space, and `select="none"`, fall through untouched; only
 * once the press is ours do we consume it, so the Reka-wrapped rendering
 * modes (which never bind this handler) keep Space for their own item.
-* Selectability is NOT re-checked here: `toggleActiveSelection` gates on
-* `rowSelectable` itself, which is the single place that rule lives.
 */
 function onSelectControlKeydown(event, index, mode, state) {
 	if (event.key !== " ") return;
 	if (mode === "none") return;
 	event.preventDefault();
 	event.stopPropagation();
-	state.setActive(index);
-	state.toggleActiveSelection(mode);
+	toggleRowAt(index, mode, state);
 }
 //#endregion
 //#region src/composables/preset-aspect-display.ts
@@ -1022,7 +1050,7 @@ function createPresetState(opts) {
 			},
 			apply(o, value, isSystem) {
 				if (!value && !isSystem) return;
-				o.filters.value = value ? { ...value } : {};
+				o.filters.value = value ? { ...(0, _atscript_ui_table.compactFieldFilters)(value) } : {};
 				if (o.residualFilters?.value.length) o.residualFilters.value = [];
 			},
 			expandDefault: () => ({})
@@ -1101,8 +1129,25 @@ function createPresetState(opts) {
 			nextActiveId: id
 		};
 	}
+	/**
+	* The one write-side prune: drop what names a field this table cannot use,
+	* and report it. A no-op before the table definition loads — bootstrap
+	* waits for it, and the query gate covers any other early writer.
+	*/
+	function pruneForApply(snapshot, presetId) {
+		const known = opts.knownFields?.value;
+		if (!known) return snapshot;
+		const { snapshot: pruned, dropped } = (0, _atscript_ui_table.prunePresetSnapshot)(snapshot, known);
+		if (dropped) opts.onFieldsDropped?.({
+			...dropped,
+			source: "preset",
+			presetId: presetId ?? void 0
+		});
+		return pruned;
+	}
 	function apply(idOrSnapshot) {
-		const { snapshot, nextActiveId } = resolveSnapshot(idOrSnapshot);
+		const { snapshot: resolved, nextActiveId } = resolveSnapshot(idOrSnapshot);
+		const snapshot = pruneForApply(resolved, nextActiveId);
 		const isSystem = typeof idOrSnapshot === "string" && nextActiveId !== null && (0, _atscript_ui_table.isSystemPresetId)(nextActiveId);
 		for (const aspect of ownedAspects(nextActiveId)) {
 			const value = snapshot[aspect];
@@ -1143,7 +1188,8 @@ function createPresetState(opts) {
 		}
 		return out;
 	}
-	const activeSnapshot = (0, vue.computed)(() => {
+	/** The active preset's snapshot as stored — the base `saveActive` merges back into. */
+	const storedActiveSnapshot = (0, vue.computed)(() => {
 		const id = activeId.value;
 		if (!id) return {};
 		if ((0, _atscript_ui_table.isSystemPresetId)(id)) return expandSystemSnapshot(systemPresetsById.value.get(id)?.content ?? {}, id);
@@ -1152,6 +1198,29 @@ function createPresetState(opts) {
 		const wire = row.data?.content;
 		return wire ? (0, _atscript_ui_table.fromWireSnapshot)(wire) : {};
 	});
+	const defaultWidths = (0, vue.computed)((prev) => {
+		const next = {};
+		for (const [path, entry] of Object.entries(opts.columnWidths.value)) next[path] = entry.d;
+		return prev && shallowEqual(prev, next) ? prev : next;
+	});
+	const prunedActive = (0, vue.computed)(() => {
+		const known = opts.knownFields?.value;
+		const stored = storedActiveSnapshot.value;
+		return known ? (0, _atscript_ui_table.prunePresetSnapshot)(stored, known) : {
+			snapshot: stored,
+			dropped: null
+		};
+	});
+	const activeSnapshot = (0, vue.computed)(() => (0, _atscript_ui_table.canonicalPresetSnapshot)(prunedActive.value.snapshot, defaultWidths.value));
+	const droppedFields = (0, vue.computed)(() => {
+		const dropped = prunedActive.value.dropped;
+		const presetId = activeId.value;
+		return dropped && presetId ? {
+			...dropped,
+			source: "preset",
+			presetId
+		} : null;
+	});
 	const isDirty = (0, vue.computed)(() => (0, _atscript_ui_table.isDirtyAgainst)(activeSnapshot.value, captureSnapshot()) || activeSnapshot.value.filterOps !== void 0 && !!opts.residualFilters?.value.length);
 	function requirePresets() {
 		if (!opts.presetsHandle) throw new Error("[vue-table] presets feature not configured (preset.url missing)");
@@ -1163,10 +1232,12 @@ function createPresetState(opts) {
 			const id = activeId.value;
 			if (!id) throw new Error("[vue-table] saveActive: no active preset");
 			if ((0, _atscript_ui_table.isSystemPresetId)(id)) throw new Error("[vue-table] saveActive: system presets cannot be overwritten");
-			const existing = activeSnapshot.value;
+			const existing = storedActiveSnapshot.value;
 			const mask = {};
 			for (const aspect of availableAspects) if (existing[aspect] !== void 0) mask[aspect] = true;
-			await handle.savePreset(captureSnapshot(mask));
+			const captured = captureSnapshot(mask);
+			const dropped = prunedActive.value.dropped;
+			await handle.savePreset(dropped ? (0, _atscript_ui_table.restoreDroppedEntries)(captured, dropped) : captured);
 			clearLocalDraft();
 		});
 	}
@@ -1225,20 +1296,25 @@ function createPresetState(opts) {
 	function bootstrap() {
 		if (!opts.presetsHandle) return;
 		const handle = opts.presetsHandle;
-		const stop = (0, vue.watch)(() => handle.loading.value, (loading) => {
-			if (loading) return;
-			stop();
+		const knownReady = () => !opts.knownFields || opts.knownFields.value !== null;
+		let done = false;
+		let stop;
+		stop = (0, vue.watch)(() => !handle.loading.value && knownReady(), (ready) => {
+			if (!ready || done) return;
+			done = true;
+			stop?.();
 			const id = resolveDefaultId();
 			const { snapshot, nextActiveId } = resolveSnapshot(id);
 			const base = (0, _atscript_ui_table.isSystemPresetId)(id) ? expandSystemSnapshot(snapshot, id) : snapshot;
 			const draftEnabled = !!(opts.draftHandle && opts.persistDrafts);
-			apply(draftEnabled ? opts.draftHandle.hydrate(base) : base);
+			apply(pruneForApply(draftEnabled ? opts.draftHandle.hydrate(base) : base, nextActiveId));
 			activeId.value = nextActiveId;
 			if (draftEnabled) opts.draftHandle.watchAndPersist(() => captureSnapshot(), () => activeSnapshot.value);
 			(0, vue.nextTick)(() => {
 				gate.value = true;
 			});
 		}, { immediate: true });
+		if (done) stop();
 	}
 	return {
 		slice: {
@@ -1254,6 +1330,7 @@ function createPresetState(opts) {
 			available,
 			activeId,
 			activeSnapshot,
+			droppedFields,
 			isDirty,
 			canSaveActive,
 			currentUser,
@@ -1282,6 +1359,12 @@ function createPresetState(opts) {
 		}
 	};
 }
+function shallowEqual(a, b) {
+	const keys = Object.keys(a);
+	if (keys.length !== Object.keys(b).length) return false;
+	for (const k of keys) if (a[k] !== b[k]) return false;
+	return true;
+}
 function inertMutator() {
 	throw new Error("[vue-table] presets feature not configured (preset.url missing)");
 }
@@ -1607,6 +1690,15 @@ function warnUnsupportedFilter(issue) {
 	if (!_atscript_ui_table.DEV) return;
 	console.warn(`[vue-table] URL filter left out (${issue.reason}): ${JSON.stringify(issue.expr)}. Field filters cannot express it, so the table shows more rows than the URL described.`);
 }
+/**
+* The report for fields the table left out when nobody handles it
+* (`onFieldsDropped` / `@fields-dropped`): a dev-mode warning.
+*/
+function warnFieldsDropped(report) {
+	if (!_atscript_ui_table.DEV) return;
+	const from = report.presetId ? `${report.source} "${report.presetId}"` : report.source;
+	console.warn(`[vue-table] Left out fields this table cannot use (${from}): ${report.fields.join(", ")}.`);
+}
 function createTableState(opts) {
 	const client = opts.client;
 	const modelOpts = opts.model;
@@ -1681,6 +1773,28 @@ function createTableState(opts) {
 	const configDialogOpen = (0, vue.ref)(false);
 	const configTab = (0, vue.ref)("columns");
 	const filterDialogColumn = (0, vue.ref)(null);
+	/**
+	* The paths the table can use, from its column list: every column, and the
+	* server-backed ones. `null` until the table definition loads. Presets,
+	* drafts, URLs and the query itself are all pruned against it.
+	*/
+	const knownFields = (0, vue.computed)(() => {
+		const all = allColumns.value;
+		if (all.length === 0) return null;
+		const columns = /* @__PURE__ */ new Set();
+		const server = /* @__PURE__ */ new Set();
+		for (const c of all) {
+			columns.add(c.path);
+			if (!c.local) server.add(c.path);
+		}
+		return {
+			columns,
+			server
+		};
+	});
+	function reportFieldsDropped(report) {
+		(queryOpts?.onFieldsDropped ?? warnFieldsDropped)(report);
+	}
 	const { slice: presetSlice, internals: presetInternals } = createPresetState({
 		columnNames,
 		columnWidths,
@@ -1695,7 +1809,9 @@ function createTableState(opts) {
 		availableAspects: opts.preset?.availableAspects,
 		systemAspects: opts.preset?.systemAspects,
 		persistDrafts: opts.preset?.persistDrafts,
-		fallbackSystemPresets: opts.preset?.fallbackSystemPresets
+		fallbackSystemPresets: opts.preset?.fallbackSystemPresets,
+		knownFields,
+		onFieldsDropped: reportFieldsDropped
 	});
 	presetInternals.bootstrap();
 	const promptSlot = createRequestSlot(false);
@@ -1737,7 +1853,10 @@ function createTableState(opts) {
 	*/
 	const localColumnPaths = (0, vue.computed)(() => {
 		const out = /* @__PURE__ */ new Set();
-		for (const c of allColumns.value) if (c.local) out.add(c.path);
+		const known = knownFields.value;
+		if (known) {
+			for (const p of known.columns) if (!known.server.has(p)) out.add(p);
+		}
 		return out;
 	});
 	/**
@@ -1770,22 +1889,67 @@ function createTableState(opts) {
 		if (splitSorters.value.local.length === 0 || sortersIgnored()) return rows;
 		return (0, _atscript_ui_table.sortRowsLocally)(rows, queryOpts?.forceSorters?.length ? (0, _atscript_ui_table.mergeSorters)(queryOpts.forceSorters, sorters.value) : sorters.value, sortValueOf);
 	}
+	/**
+	* The query's view of the model, gated to the fields this caller can use.
+	* This is the guarantee that no table state sends a field the server does
+	* not expose: presets and URLs are pruned on apply, but `setFieldFilter`,
+	* `addFilterField`, `v-model` writes, `setResidualFilters` and the like
+	* write straight to the model. `$select` is gated by the column list
+	* (`knownFields.columns`, then client-owned columns are stripped); filters
+	* and residual conditions by the server-backed columns. `forceFilters` /
+	* `forceSorters` are app-authored and never gated. Memoized: pages,
+	* window blocks and exports reuse it.
+	*/
+	const queryModel = (0, vue.computed)(() => {
+		const model = {
+			columnNames: columnNames.value,
+			filters: filters.value,
+			sorters: splitSorters.value.server,
+			residual: residualFilters.value,
+			stripped: []
+		};
+		const known = knownFields.value;
+		if (!known) return model;
+		const { snapshot, dropped } = (0, _atscript_ui_table.prunePresetSnapshot)({
+			columns: { columnNames: model.columnNames },
+			filterOps: model.filters,
+			sorters: model.sorters
+		}, known);
+		const residual = (0, _atscript_ui_table.pruneResidualFilters)(model.residual, known.server);
+		return {
+			columnNames: model.columnNames,
+			filters: snapshot.filterOps,
+			sorters: snapshot.sorters,
+			residual: residual.kept,
+			stripped: [...new Set([...dropped?.fields ?? [], ...residual.dropped?.fields ?? []])]
+		};
+	});
+	/** Stripped path sets already warned about — one dev warning per set. */
+	const warnedStripped = /* @__PURE__ */ new Set();
 	function buildCurrentQuery(buildOpts) {
-		const available = tableDef.value?.fetchableFields ?? new Set(allColumns.value.map((c) => c.path));
+		const available = tableDef.value?.fetchableFields ?? knownFields.value?.columns ?? /* @__PURE__ */ new Set();
 		const extra = /* @__PURE__ */ new Set();
 		for (const c of columns.value) for (const p of c.selectWith ?? []) if (available.has(p)) extra.add(p);
 		if (queryOpts?.alwaysSelected) {
 			for (const p of queryOpts.alwaysSelected) if (available.has(p)) extra.add(p);
 		}
+		const model = queryModel.value;
+		if (_atscript_ui_table.DEV && model.stripped.length > 0) {
+			const key = model.stripped.join(",");
+			if (!warnedStripped.has(key)) {
+				warnedStripped.add(key);
+				console.warn(`[vue-table] Query leaves out fields this table cannot use: ${model.stripped.join(", ")}.`);
+			}
+		}
+		const known = knownFields.value;
 		const localPaths = localColumnPaths.value;
-		const requested = buildOpts?.columnPaths ?? columnNames.value;
 		return (0, _atscript_ui_table.buildTableQuery)({
-			visibleColumnPaths: localPaths.size ? requested.filter((p) => !localPaths.has(p)) : requested,
+			visibleColumnPaths: (buildOpts?.columnPaths ?? model.columnNames).filter((p) => !localPaths.has(p) && (!known || known.columns.has(p))),
 			extraSelect: extra.size ? [...extra] : void 0,
-			sorters: splitSorters.value.server,
+			sorters: model.sorters,
 			forceSorters: queryOpts?.forceSorters,
-			filters: filters.value,
-			residualFilters: residualFilters.value,
+			filters: model.filters,
+			residualFilters: model.residual,
 			forceFilters: queryOpts?.forceFilters,
 			search: searchTerm.value || void 0,
 			ignoreSorters: sortersIgnored(),
@@ -1843,7 +2007,7 @@ function createTableState(opts) {
 		if (idx < 0) return void 0;
 		return navMode.value === "window" ? dataAt(idx) : results.value[idx];
 	}
-	const { selectedRows, selectedCount, rowValueFn, isPkSelected, rowSelectable, isRowSelectable, selectableRows, selectableCount, selectAll, toggleActiveSelection } = createSelectionApi(selectionOpts, getActiveRow, activeIndex);
+	const { selectedRows, selectedCount, rowValueFn, isPkSelected, rowSelectable, isRowSelectable, selectableRows, selectableCount, selectAll, deselectAll, toggleAll, clearSelection, toggleActiveSelection } = createSelectionApi(selectionOpts, getActiveRow, activeIndex);
 	const { actions } = createActions({
 		tableDef,
 		client,
@@ -2018,6 +2182,9 @@ function createTableState(opts) {
 		selectableRows,
 		selectableCount,
 		selectAll,
+		deselectAll,
+		toggleAll,
+		clearSelection,
 		rowDelete,
 		rowActions,
 		includeActions,
@@ -2081,14 +2248,11 @@ function createTableState(opts) {
 			filterFields.value = filterFields.value.filter((f) => f !== path);
 		},
 		setFieldFilter(path, conditions) {
-			if (!conditions.some(_atscript_ui_table.isFilled)) {
-				if (!(path in filters.value)) return;
-				const { [path]: _, ...rest } = filters.value;
-				filters.value = rest;
-			} else filters.value = {
+			if (!conditions.some(_atscript_ui_table.isFilled) && !(path in filters.value)) return;
+			filters.value = (0, _atscript_ui_table.compactFieldFilters)({
 				...filters.value,
 				[path]: conditions
-			};
+			});
 		},
 		setColumnWidth(path, width) {
 			writeColumnWidth(path, width);
@@ -2179,12 +2343,28 @@ function createTableState(opts) {
 	function applyUrlQuery(urlString, opts) {
 		captureUrlBaseline();
 		if (urlsEquivalent(urlString, lastEmittedUrl)) return;
-		const cols = allColumns.value;
+		const known = knownFields.value;
 		const parsed = (0, _atscript_ui_table.urlQueryStringToState)(urlString, {
-			knownFields: cols.length > 0 ? cols.filter((c) => !c.local).map((c) => c.path) : void 0,
+			knownFields: known?.server,
+			localFields: known ? localColumnPaths.value : void 0,
 			sync: urlQuerySync
 		});
 		for (const issue of parsed.unsupported ?? []) (queryOpts?.onUnsupportedFilter ?? warnUnsupportedFilter)(issue);
+		if (parsed.unknown || parsed.unknownSorters) {
+			const residual = parsed.unknown?.map((u) => u.expr) ?? [];
+			const sorters = parsed.unknownSorters ?? [];
+			const fields = new Set(parsed.unknown?.flatMap((u) => u.fields));
+			for (const s of sorters) fields.add(s.field);
+			reportFieldsDropped({
+				source: "url",
+				fields: [...fields],
+				columns: [],
+				filterFields: [],
+				filters: {},
+				residual,
+				sorters
+			});
+		}
 		const urlResidual = parsed.residual ?? [];
 		const residualPaths = new Set(urlResidual.flatMap((expr) => (0, _atscript_ui_table.filterExprFields)(expr)));
 		const base = (opts?.mode ? opts.mode === "replace" : parsed.snapshot === true) ? null : urlBaseline;
@@ -2631,6 +2811,18 @@ Object.defineProperty(exports, "rowActionHref", {
 		return rowActionHref;
 	}
 });
+Object.defineProperty(exports, "toSelectAllState", {
+	enumerable: true,
+	get: function() {
+		return toSelectAllState;
+	}
+});
+Object.defineProperty(exports, "toggleRowAt", {
+	enumerable: true,
+	get: function() {
+		return toggleRowAt;
+	}
+});
 Object.defineProperty(exports, "triggerAction", {
 	enumerable: true,
 	get: function() {
@@ -2655,6 +2847,12 @@ Object.defineProperty(exports, "useTableContextOptional", {
 		return useTableContextOptional;
 	}
 });
+Object.defineProperty(exports, "warnFieldsDropped", {
+	enumerable: true,
+	get: function() {
+		return warnFieldsDropped;
+	}
+});
 Object.defineProperty(exports, "warnUnsupportedFilter", {
 	enumerable: true,
 	get: function() {