@react-querybuilder/core 8.23.0 → 8.24.0

package/dist/cjs/react-querybuilder_core.cjs.development.js

@@ -44,6 +44,7 @@ const controlKeys = [
 	"ruleGroupHeaderElements",
 	"shiftActions",
 	"undoRedoActions",
+	"ungroupAction",
 	"valueEditor",
 	"valueSelector",
 	"valueSourceSelector"
@@ -454,6 +455,7 @@ const controlPropKeys = {
 		"toggleLockGroup",
 		"toggleMuteGroup",
 		"translations",
+		"ungroup",
 		"validationClassName",
 		"validationResult"
 	],
@@ -501,6 +503,7 @@ const controlPropKeys = {
 		"toggleLockGroup",
 		"toggleMuteGroup",
 		"translations",
+		"ungroup",
 		"validationClassName",
 		"validationResult"
 	],
@@ -537,6 +540,22 @@ const controlPropKeys = {
 		"titles",
 		"validation"
 	],
+	ungroupAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
 	valueEditor: [
 		"className",
 		"context",
@@ -637,6 +656,7 @@ const controlKind = {
 	ruleGroupHeaderElements: null,
 	shiftActions: null,
 	undoRedoActions: null,
+	ungroupAction: "action",
 	valueEditor: null,
 	valueSelector: null,
 	valueSourceSelector: "selector"
@@ -764,6 +784,10 @@ const defaultTranslations = {
 		label: "⧉",
 		title: "Clone group"
 	},
+	ungroupRuleGroup: {
+		label: "⊟",
+		title: "Ungroup"
+	},
 	shiftActionUp: {
 		label: "˄",
 		title: "Shift up"
@@ -1091,6 +1115,7 @@ const standardClassnames = {
 	addGroup: "ruleGroup-addGroup",
 	cloneRule: "rule-cloneRule",
 	cloneGroup: "ruleGroup-cloneGroup",
+	ungroup: "ruleGroup-ungroup",
 	removeGroup: "ruleGroup-remove",
 	notToggle: "ruleGroup-notToggle",
 	rule: "rule",
@@ -1145,6 +1170,7 @@ const defaultControlClassnames = {
 	addGroup: "",
 	cloneRule: "",
 	cloneGroup: "",
+	ungroup: "",
 	removeGroup: "",
 	notToggle: "",
 	rule: "",
@@ -1206,6 +1232,7 @@ const TestID = {
 	addGroup: "add-group",
 	removeGroup: "remove-group",
 	cloneGroup: "clone-group",
+	ungroup: "ungroup",
 	cloneRule: "clone-rule",
 	addRule: "add-rule",
 	removeRule: "remove-rule",
@@ -1237,11 +1264,13 @@ const LogType = {
 	onMoveRuleFalse: "onMoveRule callback returned false",
 	onMoveGroupFalse: "onMoveGroup callback returned false",
 	onRemoveFalse: "onRemove callback returned false",
+	onUngroupFalse: "onUngroup callback returned false",
 	add: "rule or group added",
 	remove: "rule or group removed",
 	update: "rule or group updated",
 	move: "rule or group moved",
-	group: "rule or group grouped with another"
+	group: "rule or group grouped with another",
+	ungroup: "group replaced by its own rules"
 };
 /**
 * The {@link Path} of the root group.
@@ -1274,6 +1303,7 @@ const queryBuilderFlagDefaults = {
 	showNotToggle: false,
 	showShiftActions: false,
 	showUndoRedo: false,
+	showUngroupButtons: false,
 	suppressStandardClassnames: false
 };
 /**
@@ -1305,6 +1335,7 @@ const strictAbortReasons = [
 	"target-not-found",
 	"parent-not-found",
 	"parent-not-a-group",
+	"target-not-a-group",
 	"destination-not-found",
 	"root-not-allowed",
 	"not-a-combinator-slot",
@@ -1632,6 +1663,7 @@ const ruleGroupClassnameSources = {
 	addRule: ["actionElement", "addRule"],
 	addGroup: ["actionElement", "addGroup"],
 	cloneGroup: ["actionElement", "cloneGroup"],
+	ungroup: ["actionElement", "ungroup"],
 	lockGroup: ["actionElement", "lockGroup"],
 	muteGroup: ["actionElement", "muteGroup"],
 	removeGroup: ["actionElement", "removeGroup"],
@@ -3452,7 +3484,9 @@ const defaultRuleGroupProcessorElasticSearch = (ruleGroup, options) => {
 *
 * At the top level, filter rules produce chained `.has()` steps (implicit AND).
 * Nested groups use `.and()` / `.or()` / `.not()` compound traversals with
-* `__` anonymous traversal prefixes.
+* `__` anonymous traversal prefixes. Since `not()` accepts exactly one
+* traversal, negated groups with multiple predicates wrap them in a single
+* `__.and()`/`__.or()` sub-traversal.
 *
 * @group Export
 */
@@ -3489,9 +3523,10 @@ const defaultRuleGroupProcessorGremlin = (ruleGroup, options) => {
 		}
 		if (predicates.length === 0) return "";
 		const combinator = rg.combinator ?? "and";
-		const prefix = rg.not ? "not" : combinator;
 		if (predicates.length === 1 && !rg.not) return predicates[0];
-		return `.${prefix}(${predicates.map((p) => p.startsWith(".") ? `__${p}` : p).join(", ")})`;
+		const args = predicates.map((p) => p.startsWith(".") ? `__${p}` : p).join(", ");
+		if (rg.not) return predicates.length === 1 ? `.not(${args})` : `.not(__.${combinator}(${args}))`;
+		return `.${combinator}(${args})`;
 	};
 	if (!isRuleOrGroupValid(ruleGroup, validationMap[ruleGroup.id ?? /* v8 ignore start -- @preserve */ ""])) return fallbackExpression;
 	const steps = [];
@@ -6282,6 +6317,7 @@ const mergeClassnames = (...args) => ({
 	addGroup: joinClassnamesByName("addGroup", args),
 	cloneRule: joinClassnamesByName("cloneRule", args),
 	cloneGroup: joinClassnamesByName("cloneGroup", args),
+	ungroup: joinClassnamesByName("ungroup", args),
 	removeGroup: joinClassnamesByName("removeGroup", args),
 	rule: joinClassnamesByName("rule", args),
 	fields: joinClassnamesByName("fields", args),
@@ -6844,6 +6880,81 @@ const removeInPlace = (query, pathOrID, options = {}) => {
 	} else parent.rules.splice(index, 1);
 	return query;
 };
+/**
+* Replaces a group with its own rules in its parent group, without mutating the original query.
+*
+* The group's `combinator`, `not`, `id`, `muted`, and `disabled` properties are discarded; its
+* rules keep their `id`s since they remain in the same query. An empty group is simply removed.
+*
+* @returns A new query with the group's rules promoted into its parent group.
+*
+* @group Query Tools
+*/
+const ungroup = (query, pathOrID, options = {}) => producerFor(options.freeze)(query, (q) => ungroupInPlace(q, pathOrID, options));
+/**
+* Replaces a group with its own rules in its parent group, in place.
+*
+* @returns The query (mutated in place) with the group's rules promoted into its parent group.
+*
+* @group Query Tools
+*/
+const ungroupInPlace = (query, pathOrID, options = {}) => {
+	const { onAbort } = options;
+	const path = Array.isArray(pathOrID) ? pathOrID : getPathOfID(pathOrID, query);
+	if (!path) {
+		onAbort?.({
+			reason: "target-not-found",
+			operation: "ungroup",
+			pathOrID
+		});
+		return query;
+	}
+	if (path.length === 0) {
+		onAbort?.({
+			reason: "root-not-allowed",
+			operation: "ungroup",
+			pathOrID
+		});
+		return query;
+	}
+	const ungroupGuardReason = getGuardAbortReason(query, path, options);
+	if (ungroupGuardReason) {
+		onAbort?.({
+			reason: ungroupGuardReason,
+			operation: "ungroup",
+			pathOrID
+		});
+		return query;
+	}
+	const target = findPath(path, query);
+	if (!target) {
+		onAbort?.({
+			reason: "target-not-found",
+			operation: "ungroup",
+			pathOrID
+		});
+		return query;
+	}
+	if (!isRuleGroup(target)) {
+		onAbort?.({
+			reason: "target-not-a-group",
+			operation: "ungroup",
+			pathOrID
+		});
+		return query;
+	}
+	const index = path.at(-1);
+	const parent = findPath(getParentPath(path), query);
+	if (target.rules.length === 0) {
+		if (!isRuleGroupType(parent) && parent.rules.length > 1) {
+			const idxStartDelete = index === 0 ? 0 : index - 1;
+			parent.rules.splice(idxStartDelete, 2);
+		} else parent.rules.splice(index, 1);
+		return query;
+	}
+	parent.rules.splice(index, 1, ...target.rules);
+	return query;
+};
 const getNextPath = (query, currentPath, newPathOrShiftDirection) => {
 	if (Array.isArray(newPathOrShiftDirection)) return newPathOrShiftDirection;
 	const ic = isRuleGroupTypeIC(query);
@@ -7182,7 +7293,7 @@ const groupInPlace = (query, sourcePathOrID, targetPathOrID, options = {}) => {
 //#endregion
 //#region src/utils/queryActions.ts
 /**
-* Builds the query builder's six mutation handlers as pure functions of the current query.
+* Builds the query builder's seven mutation handlers as pure functions of the current query.
 *
 * This is the framework-agnostic core of the action handlers in `useQueryBuilderSchema`. It owns
 * the policy that surrounds the query tools—disabled gating, the confirmation callback protocol,
@@ -7192,7 +7303,7 @@ const groupInPlace = (query, sourcePathOrID, targetPathOrID, options = {}) => {
 * @group Query Tools
 */
 const createQueryActions = (config = {}) => {
-	const { qbId, combinators, idGenerator, maxLevels = Infinity, queryDisabled, respectDisabled = true, disabledPaths, resetOnFieldChange, resetOnOperatorChange, getRuleDefaultOperator, getValueSources, getRuleDefaultValue, getMatchModes, freeze, onAddRule, onAddGroup, onRemove, onMoveRule, onMoveGroup, onGroupRule, onGroupGroup, onLog } = config;
+	const { qbId, combinators, idGenerator, maxLevels = Infinity, queryDisabled, respectDisabled = true, disabledPaths, resetOnFieldChange, resetOnOperatorChange, getRuleDefaultOperator, getValueSources, getRuleDefaultValue, getMatchModes, freeze, onAddRule, onAddGroup, onRemove, onMoveRule, onMoveGroup, onGroupRule, onGroupGroup, onUngroup, onLog } = config;
 	const log = (payload) => onLog?.({
 		qbId,
 		...payload
@@ -7432,6 +7543,39 @@ const createQueryActions = (config = {}) => {
 				clone
 			});
 			return newQuery;
+		},
+		ungroupRuleGroup: (query, path, context) => {
+			if (blocked(query, path)) {
+				log({
+					type: LogType.pathDisabled,
+					path,
+					query
+				});
+				return;
+			}
+			const ruleGroup = findPath(path, query);
+			if (path.length === 0 || !isRuleGroup(ruleGroup)) return void 0;
+			const nextQuery = ungroup(query, path, { freeze });
+			const callbackResult = onUngroup ? onUngroup(ruleGroup, path, query, nextQuery, context) : true;
+			if (!callbackResult) {
+				log({
+					type: LogType.onUngroupFalse,
+					ruleGroup,
+					path,
+					query,
+					nextQuery
+				});
+				return;
+			}
+			const newQuery = isRuleGroup(callbackResult) ? callbackResult : nextQuery;
+			log({
+				type: LogType.ungroup,
+				query,
+				newQuery,
+				path,
+				ruleGroup
+			});
+			return newQuery;
 		}
 	};
 };
@@ -7999,6 +8143,23 @@ var QueryManager = class QueryManager {
 		return this;
 	}
 	/**
+	* Replaces the group at `pathOrID` with its own rules in the parent group. The group's
+	* `combinator`, `not`, `id`, `muted`, and `disabled` properties are discarded; an empty group
+	* is simply removed.
+	*/
+	ungroup(pathOrID, options = {}) {
+		const { strict, onInvalidTarget, ...toolOptions } = options;
+		this.commit(ungroup(this.state.query, pathOrID, {
+			...this.toolOptions(),
+			...toolOptions,
+			onAbort: this.onAbort({
+				strict,
+				onInvalidTarget
+			})
+		}));
+		return this;
+	}
+	/**
 	* The options currently in effect, as a frozen shallow copy. Reflects everything applied by
 	* the constructor and any subsequent {@link QueryManager.reconfigure} calls, but not the
 	* defaults filled in for options that were never provided.
@@ -8763,6 +8924,8 @@ exports.toFullOptionMap = toFullOptionMap;
 exports.transformQuery = transformQuery;
 exports.trimIfString = trimIfString;
 exports.unchangedSignature = unchangedSignature;
+exports.ungroup = ungroup;
+exports.ungroupInPlace = ungroupInPlace;
 exports.uniqByIdentifier = uniqByIdentifier;
 exports.uniqByName = uniqByName;
 exports.uniqOptGroups = uniqOptGroups;