@react-querybuilder/material/dist/react-querybuilder_material.legacy-esm.js

Custom MUI (Material Design) components for react-querybuilder

import * as React from "react";
import { createContext, forwardRef, useContext, useMemo } from "react";
import { ActionElement, DragHandle, NotToggle, ShiftActions, ValueEditor, ValueSelector, defaultTranslations, getCompatContextProvider, getFirstOption, isOptionGroupArray, parseNumber, useValueEditor, useValueSelector } from "react-querybuilder";
import { Close, ContentCopy, DragIndicator, KeyboardArrowDown, KeyboardArrowUp, Lock, LockOpen } from "@mui/icons-material";
import { Button, Checkbox, FormControl, FormControlLabel, InputLabel, ListSubheader, MenuItem, Radio, RadioGroup, Select, Switch, TextField, TextareaAutosize } from "@mui/material";

//#region src/RQBMaterialContext.ts
/**
* @group Components
*/
const RQBMaterialContext = createContext(null);

//#endregion
//#region \0@oxc-project+runtime@0.95.0/helpers/objectWithoutPropertiesLoose.js
function _objectWithoutPropertiesLoose(r, e) {
	if (null == r) return {};
	var t = {};
	for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
		if (e.includes(n)) continue;
		t[n] = r[n];
	}
	return t;
}

//#endregion
//#region \0@oxc-project+runtime@0.95.0/helpers/objectWithoutProperties.js
function _objectWithoutProperties(e, t) {
	if (null == e) return {};
	var o, r, i = _objectWithoutPropertiesLoose(e, t);
	if (Object.getOwnPropertySymbols) {
		var s = Object.getOwnPropertySymbols(e);
		for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
	}
	return i;
}

//#endregion
//#region \0@oxc-project+runtime@0.95.0/helpers/typeof.js
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
		return typeof o$1;
	} : function(o$1) {
		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
	}, _typeof(o);
}

//#endregion
//#region \0@oxc-project+runtime@0.95.0/helpers/toPrimitive.js
function toPrimitive(t, r) {
	if ("object" != _typeof(t) || !t) return t;
	var e = t[Symbol.toPrimitive];
	if (void 0 !== e) {
		var i = e.call(t, r || "default");
		if ("object" != _typeof(i)) return i;
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}

//#endregion
//#region \0@oxc-project+runtime@0.95.0/helpers/toPropertyKey.js
function toPropertyKey(t) {
	var i = toPrimitive(t, "string");
	return "symbol" == _typeof(i) ? i : i + "";
}

//#endregion
//#region \0@oxc-project+runtime@0.95.0/helpers/defineProperty.js
function _defineProperty(e, r, t) {
	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
		value: t,
		enumerable: !0,
		configurable: !0,
		writable: !0
	}) : e[r] = t, e;
}

//#endregion
//#region \0@oxc-project+runtime@0.95.0/helpers/objectSpread2.js
function ownKeys(e, r) {
	var t = Object.keys(e);
	if (Object.getOwnPropertySymbols) {
		var o = Object.getOwnPropertySymbols(e);
		r && (o = o.filter(function(r$1) {
			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
		})), t.push.apply(t, o);
	}
	return t;
}
function _objectSpread2(e) {
	for (var r = 1; r < arguments.length; r++) {
		var t = null != arguments[r] ? arguments[r] : {};
		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
			_defineProperty(e, r$1, t[r$1]);
		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
		});
	}
	return e;
}

//#endregion
//#region src/MaterialActionElement.tsx
const _excluded$6 = [
	"className",
	"handleOnClick",
	"label",
	"title",
	"disabled",
	"disabledTranslation",
	"testID",
	"path",
	"level",
	"rules",
	"context",
	"validation",
	"ruleOrGroup",
	"schema",
	"muiComponents"
];
/**
* @group Components
*/
const MaterialActionElement = (_ref) => {
	var _useContext;
	let { className, handleOnClick, label, title, disabled, disabledTranslation, testID, path, level, rules, context, validation, ruleOrGroup, schema, muiComponents: muiComponentsProp } = _ref, otherProps = _objectWithoutProperties(_ref, _excluded$6);
	const muiComponents = (_useContext = useContext(RQBMaterialContext)) !== null && _useContext !== void 0 ? _useContext : muiComponentsProp;
	const key = muiComponents ? "mui" : "no-mui";
	if (!muiComponents) {
		const AE = ActionElement;
		return /* @__PURE__ */ React.createElement(AE, {
			key,
			className,
			handleOnClick,
			label,
			title,
			disabled,
			disabledTranslation,
			testID,
			path,
			level,
			rules,
			context,
			validation,
			ruleOrGroup,
			schema
		});
	}
	const { Button: Button$1 } = muiComponents;
	return /* @__PURE__ */ React.createElement(Button$1, _objectSpread2({
		key,
		variant: "contained",
		color: "secondary",
		className,
		title: disabledTranslation && disabled ? disabledTranslation.title : title,
		size: "small",
		disabled: disabled && !disabledTranslation,
		onClick: (e) => handleOnClick(e)
	}, otherProps), disabledTranslation && disabled ? disabledTranslation.label : label);
};

//#endregion
//#region src/MaterialDragHandle.tsx
const _excluded$5 = [
	"className",
	"title",
	"path",
	"level",
	"testID",
	"label",
	"disabled",
	"context",
	"validation",
	"schema",
	"ruleOrGroup",
	"muiComponents"
];
/**
* @group Components
*/
const MaterialDragHandle = forwardRef((_ref, dragRef) => {
	var _useContext;
	let { className, title, path, level, testID, label, disabled, context, validation, schema, ruleOrGroup, muiComponents: muiComponentsProp } = _ref, otherProps = _objectWithoutProperties(_ref, _excluded$5);
	const muiComponents = (_useContext = useContext(RQBMaterialContext)) !== null && _useContext !== void 0 ? _useContext : muiComponentsProp;
	const key = muiComponents ? "mui" : "no-mui";
	if (!muiComponents) return /* @__PURE__ */ React.createElement(DragHandle, {
		key,
		path,
		level,
		className,
		title,
		testID,
		label,
		disabled,
		context,
		validation,
		schema,
		ruleOrGroup
	});
	const { DragIndicator: DragIndicator$1 } = muiComponents;
	return /* @__PURE__ */ React.createElement("span", {
		key,
		ref: dragRef,
		className,
		title
	}, /* @__PURE__ */ React.createElement(DragIndicator$1, otherProps));
});

//#endregion
//#region src/MaterialNotToggle.tsx
const _excluded$4 = [
	"className",
	"handleOnChange",
	"label",
	"checked",
	"title",
	"disabled",
	"level",
	"path",
	"context",
	"validation",
	"testID",
	"schema",
	"ruleGroup",
	"muiComponents"
];
/**
* @group Components
*/
const MaterialNotToggle = (_ref) => {
	var _useContext;
	let { className, handleOnChange, label, checked, title, disabled, level, path, context, validation, testID, schema, ruleGroup, muiComponents: muiComponentsProp } = _ref, otherProps = _objectWithoutProperties(_ref, _excluded$4);
	const muiComponents = (_useContext = useContext(RQBMaterialContext)) !== null && _useContext !== void 0 ? _useContext : muiComponentsProp;
	const { FormControlLabel: FormControlLabel$1, Switch: Switch$1 } = muiComponents !== null && muiComponents !== void 0 ? muiComponents : {};
	const switchControl = useMemo(() => Switch$1 && /* @__PURE__ */ React.createElement(Switch$1, _objectSpread2({
		checked: !!checked,
		onChange: (e) => handleOnChange(e.target.checked)
	}, otherProps)), [
		checked,
		handleOnChange,
		otherProps,
		Switch$1
	]);
	const key = muiComponents ? "mui" : "no-mui";
	if (!muiComponents) return /* @__PURE__ */ React.createElement(NotToggle, {
		key,
		className,
		handleOnChange,
		label,
		checked,
		title,
		disabled,
		path,
		level,
		context,
		validation,
		testID,
		schema,
		ruleGroup
	});
	return /* @__PURE__ */ React.createElement(FormControlLabel$1, {
		key,
		className,
		title,
		disabled,
		control: switchControl,
		label: label !== null && label !== void 0 ? label : ""
	});
};

//#endregion
//#region src/MaterialShiftActions.tsx
const _excluded$3 = [
	"path",
	"shiftUp",
	"shiftDown",
	"shiftUpDisabled",
	"shiftDownDisabled",
	"disabled",
	"className",
	"labels",
	"titles",
	"testID",
	"muiComponents"
];
/**
* @group Components
*/
const MaterialShiftActions = (_ref) => {
	var _React$useContext;
	let { path, shiftUp, shiftDown, shiftUpDisabled, shiftDownDisabled, disabled, className, labels, titles, testID, muiComponents: muiComponentsProp } = _ref, otherProps = _objectWithoutProperties(_ref, _excluded$3);
	const muiComponents = (_React$useContext = React.useContext(RQBMaterialContext)) !== null && _React$useContext !== void 0 ? _React$useContext : muiComponentsProp;
	const key = muiComponents ? "mui" : "no-mui";
	if (!muiComponents) return /* @__PURE__ */ React.createElement(ShiftActions, _objectSpread2({
		key,
		path,
		disabled,
		className,
		labels,
		titles,
		testID,
		shiftUp,
		shiftDown,
		shiftUpDisabled,
		shiftDownDisabled
	}, otherProps));
	const { Button: Button$1 } = muiComponents;
	return /* @__PURE__ */ React.createElement("div", {
		key,
		"data-testid": testID,
		className
	}, /* @__PURE__ */ React.createElement(Button$1, {
		sx: { boxShadow: "none" },
		variant: "contained",
		color: "secondary",
		className,
		title: titles === null || titles === void 0 ? void 0 : titles.shiftUp,
		size: "small",
		disabled: disabled || shiftUpDisabled,
		onClick: shiftUp
	}, labels === null || labels === void 0 ? void 0 : labels.shiftUp), /* @__PURE__ */ React.createElement(Button$1, {
		sx: { boxShadow: "none" },
		variant: "contained",
		color: "secondary",
		className,
		title: titles === null || titles === void 0 ? void 0 : titles.shiftDown,
		size: "small",
		disabled: disabled || shiftDownDisabled,
		onClick: shiftDown
	}, labels === null || labels === void 0 ? void 0 : labels.shiftDown));
};

//#endregion
//#region src/MaterialValueEditor.tsx
const _excluded$2 = ["muiComponents"], _excluded2 = [
	"field",
	"fieldData",
	"operator",
	"value",
	"handleOnChange",
	"title",
	"className",
	"type",
	"inputType",
	"path",
	"level",
	"values",
	"listsAsArrays",
	"separator",
	"valueSource",
	"disabled",
	"testID",
	"selectorComponent",
	"showInputLabels",
	"extraProps",
	"parseNumbers"
];
/**
* @group Components
*/
const MaterialValueEditor = (props) => {
	var _useContext, _fieldData$placeholde;
	const { muiComponents: muiComponentsProp } = props, propsForValueEditor = _objectWithoutProperties(props, _excluded$2);
	const { field: _f, fieldData, operator, value, handleOnChange, title, className, type, inputType, path, level, values = [], listsAsArrays, separator, valueSource: _vs, disabled, testID, selectorComponent: SelectorComponent = props.schema.controls.valueSelector, showInputLabels: silProp, extraProps, parseNumbers: _parseNumbers } = propsForValueEditor, propsForValueSelector = _objectWithoutProperties(propsForValueEditor, _excluded2);
	const muiComponents = (_useContext = useContext(RQBMaterialContext)) !== null && _useContext !== void 0 ? _useContext : muiComponentsProp;
	const { valueAsArray, multiValueHandler, bigIntValueHandler, parseNumberMethod, valueListItemClassName, inputTypeCoerced } = useValueEditor(propsForValueEditor);
	const masterKey = muiComponents ? "mui" : "no-mui";
	const { Checkbox: Checkbox$1, FormControl: FormControl$1, FormControlLabel: FormControlLabel$1, Radio: Radio$1, RadioGroup: RadioGroup$1, Switch: Switch$1, TextareaAutosize: TextareaAutosize$1, TextField: TextField$1, showInputLabels: silCtx } = useMemo(() => muiComponents !== null && muiComponents !== void 0 ? muiComponents : {}, [muiComponents]);
	if (!muiComponents) return /* @__PURE__ */ React.createElement(ValueEditor, _objectSpread2({
		skipHook: true,
		key: masterKey
	}, propsForValueEditor));
	if (operator === "null" || operator === "notNull") return null;
	const placeHolderText = (_fieldData$placeholde = fieldData === null || fieldData === void 0 ? void 0 : fieldData.placeholder) !== null && _fieldData$placeholde !== void 0 ? _fieldData$placeholde : "";
	const showInputLabels = silProp || silCtx;
	if ((operator === "between" || operator === "notBetween") && (type === "select" || type === "text")) {
		const editors = ["From", "To"].map((key, i) => {
			var _valueAsArray$i2;
			if (type === "text") {
				var _valueAsArray$i;
				return /* @__PURE__ */ React.createElement(TextField$1, _objectSpread2({
					key,
					variant: "standard",
					type: inputTypeCoerced,
					className: valueListItemClassName,
					placeholder: placeHolderText,
					value: (_valueAsArray$i = valueAsArray[i]) !== null && _valueAsArray$i !== void 0 ? _valueAsArray$i : "",
					disabled,
					label: showInputLabels ? key : void 0,
					onChange: (e) => multiValueHandler(e.target.value, i)
				}, extraProps));
			}
			return /* @__PURE__ */ React.createElement(SelectorComponent, _objectSpread2(_objectSpread2({ key }, propsForValueSelector), {}, {
				title: showInputLabels ? key : void 0,
				path,
				level,
				className: valueListItemClassName,
				handleOnChange: (v) => multiValueHandler(v, i),
				muiComponents,
				disabled,
				value: (_valueAsArray$i2 = valueAsArray[i]) !== null && _valueAsArray$i2 !== void 0 ? _valueAsArray$i2 : getFirstOption(values),
				options: values,
				listsAsArrays
			}));
		});
		return /* @__PURE__ */ React.createElement(FormControl$1, {
			key: masterKey,
			"data-testid": testID,
			className,
			title,
			disabled
		}, editors[0], separator, editors[1]);
	}
	switch (type) {
		case "select":
		case "multiselect": return /* @__PURE__ */ React.createElement(SelectorComponent, _objectSpread2(_objectSpread2({ key: masterKey }, propsForValueSelector), {}, {
			muiComponents,
			path,
			level,
			className,
			handleOnChange,
			options: values,
			value,
			disabled,
			title,
			multiple: type === "multiselect",
			listsAsArrays
		}));
		case "textarea": return /* @__PURE__ */ React.createElement(TextareaAutosize$1, _objectSpread2({
			key: masterKey,
			value,
			title,
			disabled,
			className,
			placeholder: placeHolderText,
			onChange: (e) => handleOnChange(e.target.value)
		}, extraProps));
		case "switch": return /* @__PURE__ */ React.createElement(Switch$1, _objectSpread2({
			key: masterKey,
			checked: !!value,
			title,
			disabled,
			className,
			onChange: (e) => handleOnChange(e.target.checked)
		}, extraProps));
		case "checkbox": return /* @__PURE__ */ React.createElement(Checkbox$1, _objectSpread2({
			key: masterKey,
			className,
			title,
			onChange: (e) => handleOnChange(e.target.checked),
			checked: !!value,
			disabled
		}, extraProps));
		case "radio": return /* @__PURE__ */ React.createElement(FormControl$1, _objectSpread2({
			key: masterKey,
			className,
			title,
			component: "fieldset",
			disabled
		}, extraProps), /* @__PURE__ */ React.createElement(RadioGroup$1, {
			value,
			onChange: (e) => handleOnChange(e.target.value)
		}, values.map((v) => /* @__PURE__ */ React.createElement(FormControlLabel$1, {
			key: v.name,
			disabled,
			value: v.name,
			control: /* @__PURE__ */ React.createElement(Radio$1, null),
			name: v.name,
			label: v.label
		}))));
	}
	/**
	* TODO: Provide either (1) examples or (2) alternate exports that support `inputType`
	* "date", "datetime-local", and "time", with components from `@mui/x-date-pickers`
	* (`<DatePicker />`, `<DateTimePicker />`, and `<TimePicker />`, respecitively).
	*/
	if (inputType === "bigint") return /* @__PURE__ */ React.createElement(TextField$1, _objectSpread2({
		key: masterKey,
		variant: "standard",
		"data-testid": testID,
		type: inputTypeCoerced,
		placeholder: placeHolderText,
		value: `${value}`,
		title,
		className,
		disabled,
		label: showInputLabels ? title : void 0,
		onChange: (e) => bigIntValueHandler(e.target.value)
	}, extraProps));
	return /* @__PURE__ */ React.createElement(TextField$1, _objectSpread2({
		key: masterKey,
		variant: "standard",
		type: inputTypeCoerced,
		value,
		title,
		disabled,
		className,
		placeholder: placeHolderText,
		label: showInputLabels ? title : void 0,
		onChange: (e) => handleOnChange(parseNumber(e.target.value, { parseNumbers: parseNumberMethod }))
	}, extraProps));
};

//#endregion
//#region src/utils.tsx
// istanbul ignore next
const defaultToOptionsOptions = {
	ListSubheader: () => null,
	MenuItem: () => /* @__PURE__ */ React.createElement(React.Fragment, null)
};
const toOptions = (arr = [], { ListSubheader: ListSubheader$1, MenuItem: MenuItem$1 } = defaultToOptionsOptions) => {
	if (isOptionGroupArray(arr)) {
		const optArray = [];
		for (const og of arr) optArray.push(/* @__PURE__ */ React.createElement(ListSubheader$1, { key: og.label }, og.label), ...og.options.map((opt) => /* @__PURE__ */ React.createElement(MenuItem$1, {
			key: opt.name,
			value: opt.name
		}, opt.label)));
		return optArray;
	}
	/* istanbul ignore else */
	if (Array.isArray(arr)) return arr.map((opt) => /* @__PURE__ */ React.createElement(MenuItem$1, {
		key: opt.name,
		value: opt.name
	}, opt.label));
	/* istanbul ignore next */
	return null;
};

//#endregion
//#region src/MaterialValueSelector.tsx
const _excluded$1 = [
	"className",
	"handleOnChange",
	"options",
	"value",
	"disabled",
	"title",
	"multiple",
	"listsAsArrays",
	"testID",
	"rule",
	"ruleGroup",
	"rules",
	"level",
	"path",
	"context",
	"validation",
	"operator",
	"field",
	"fieldData",
	"schema",
	"muiComponents",
	"showInputLabels",
	"defaultValue"
];
/**
* @group Components
*/
const MaterialValueSelector = (_ref) => {
	var _useContext;
	let { className, handleOnChange, options, value, disabled, title, multiple, listsAsArrays, testID, rule, ruleGroup, rules, level, path, context, validation, operator, field, fieldData, schema, muiComponents: muiComponentsProp, showInputLabels: silProp, defaultValue: _defaultValue } = _ref, otherProps = _objectWithoutProperties(_ref, _excluded$1);
	const muiComponents = (_useContext = useContext(RQBMaterialContext)) !== null && _useContext !== void 0 ? _useContext : muiComponentsProp;
	const { onChange, val } = useValueSelector({
		handleOnChange,
		listsAsArrays,
		multiple,
		value
	});
	const muiSelectChangeHandler = React.useCallback(({ target: { value: value$1 } }) => {
		onChange(value$1);
	}, [onChange]);
	const key = muiComponents ? "mui" : "no-mui";
	if (!muiComponents) {
		const VS = ValueSelector;
		return /* @__PURE__ */ React.createElement(VS, {
			key,
			className,
			handleOnChange,
			options,
			value,
			disabled,
			title,
			multiple,
			listsAsArrays,
			testID,
			rule,
			ruleGroup,
			rules,
			level,
			path,
			context,
			validation,
			operator,
			field,
			fieldData,
			schema
		});
	}
	const { FormControl: FormControl$1, InputLabel: InputLabel$1, ListSubheader: ListSubheader$1, MenuItem: MenuItem$1, Select: Select$1, showInputLabels: silCtx } = muiComponents;
	const showInputLabels = silProp || silCtx;
	return /* @__PURE__ */ React.createElement(FormControl$1, {
		key,
		variant: "standard",
		className,
		title,
		disabled
	}, showInputLabels && /* @__PURE__ */ React.createElement(InputLabel$1, null, title), /* @__PURE__ */ React.createElement(Select$1, _objectSpread2({
		value: val,
		onChange: muiSelectChangeHandler,
		multiple,
		disabled,
		label: showInputLabels ? title : void 0
	}, otherProps), toOptions(options, {
		ListSubheader: ListSubheader$1,
		MenuItem: MenuItem$1
	})));
};

//#endregion
//#region src/translations.tsx
const CloseIconWrapper = () => {
	const muiComponents = React.useContext(RQBMaterialContext);
	if (!muiComponents) return defaultTranslations.removeRule.label;
	const { CloseIcon } = muiComponents;
	return /* @__PURE__ */ React.createElement(CloseIcon, null);
};
const ContentCopyIconWrapper = () => {
	const muiComponents = React.useContext(RQBMaterialContext);
	if (!muiComponents) return defaultTranslations.cloneRule.label;
	const { ContentCopyIcon } = muiComponents;
	return /* @__PURE__ */ React.createElement(ContentCopyIcon, null);
};
const LockIconWrapper = () => {
	const muiComponents = React.useContext(RQBMaterialContext);
	if (!muiComponents) return defaultTranslations.lockRuleDisabled.label;
	const { LockIcon } = muiComponents;
	return /* @__PURE__ */ React.createElement(LockIcon, null);
};
const LockOpenIconWrapper = () => {
	const muiComponents = React.useContext(RQBMaterialContext);
	if (!muiComponents) return defaultTranslations.lockRule.label;
	const { LockOpenIcon } = muiComponents;
	return /* @__PURE__ */ React.createElement(LockOpenIcon, null);
};
const ShiftDownIconWrapper = () => {
	const muiComponents = React.useContext(RQBMaterialContext);
	if (!muiComponents) return defaultTranslations.shiftActionDown.label;
	const { KeyboardArrowDownIcon } = muiComponents;
	return /* @__PURE__ */ React.createElement(KeyboardArrowDownIcon, null);
};
const ShiftUpIconWrapper = () => {
	const muiComponents = React.useContext(RQBMaterialContext);
	if (!muiComponents) return defaultTranslations.shiftActionUp.label;
	const { KeyboardArrowUpIcon } = muiComponents;
	return /* @__PURE__ */ React.createElement(KeyboardArrowUpIcon, null);
};
const materialTranslations = {
	removeGroup: { label: /* @__PURE__ */ React.createElement(CloseIconWrapper, null) },
	removeRule: { label: /* @__PURE__ */ React.createElement(CloseIconWrapper, null) },
	cloneRule: { label: /* @__PURE__ */ React.createElement(ContentCopyIconWrapper, null) },
	cloneRuleGroup: { label: /* @__PURE__ */ React.createElement(ContentCopyIconWrapper, null) },
	lockGroup: { label: /* @__PURE__ */ React.createElement(LockOpenIconWrapper, null) },
	lockRule: { label: /* @__PURE__ */ React.createElement(LockOpenIconWrapper, null) },
	lockGroupDisabled: { label: /* @__PURE__ */ React.createElement(LockIconWrapper, null) },
	lockRuleDisabled: { label: /* @__PURE__ */ React.createElement(LockIconWrapper, null) },
	shiftActionDown: { label: /* @__PURE__ */ React.createElement(ShiftDownIconWrapper, null) },
	shiftActionUp: { label: /* @__PURE__ */ React.createElement(ShiftUpIconWrapper, null) }
};

//#endregion
//#region src/useMuiComponents.ts
const defaultMuiComponents = {
	DragIndicator,
	Button,
	Checkbox,
	CloseIcon: Close,
	ContentCopyIcon: ContentCopy,
	FormControl,
	FormControlLabel,
	InputLabel,
	KeyboardArrowDownIcon: KeyboardArrowDown,
	KeyboardArrowUpIcon: KeyboardArrowUp,
	ListSubheader,
	LockIcon: Lock,
	LockOpenIcon: LockOpen,
	MenuItem,
	Radio,
	RadioGroup,
	Select,
	Switch,
	TextareaAutosize,
	TextField
};
/**
* @group Hooks
*/
const useMuiComponents = (preloadedComponents) => {
	const muiComponentsFromContext = useContext(RQBMaterialContext);
	return useMemo(() => preloadedComponents && muiComponentsFromContext ? _objectSpread2(_objectSpread2(_objectSpread2({}, defaultMuiComponents), muiComponentsFromContext), preloadedComponents) : preloadedComponents ? _objectSpread2(_objectSpread2({}, defaultMuiComponents), preloadedComponents) : muiComponentsFromContext ? _objectSpread2(_objectSpread2({}, defaultMuiComponents), muiComponentsFromContext) : defaultMuiComponents, [muiComponentsFromContext, preloadedComponents]);
};

//#endregion
//#region src/index.tsx
const _excluded = ["muiComponents", "showInputLabels"];
/**
* @group Props
*/
const materialControlElements = {
	actionElement: MaterialActionElement,
	dragHandle: MaterialDragHandle,
	notToggle: MaterialNotToggle,
	shiftActions: MaterialShiftActions,
	valueEditor: MaterialValueEditor,
	valueSelector: MaterialValueSelector
};
const MaterialContextProvider = getCompatContextProvider({
	controlElements: materialControlElements,
	translations: materialTranslations
});
/**
* @group Components
*/
const QueryBuilderMaterial = (_ref) => {
	let { muiComponents: muiComponentsProp, showInputLabels } = _ref, props = _objectWithoutProperties(_ref, _excluded);
	const muiComponents = useMuiComponents(muiComponentsProp);
	const ctxValue = useMemo(() => _objectSpread2(_objectSpread2(_objectSpread2({}, muiComponents), muiComponentsProp), {}, { showInputLabels }), [
		muiComponents,
		muiComponentsProp,
		showInputLabels
	]);
	return /* @__PURE__ */ React.createElement(RQBMaterialContext.Provider, { value: ctxValue }, /* @__PURE__ */ React.createElement(MaterialContextProvider, props));
};

//#endregion
export { MaterialActionElement, MaterialDragHandle, MaterialNotToggle, MaterialShiftActions, MaterialValueEditor, MaterialValueSelector, QueryBuilderMaterial, RQBMaterialContext, defaultMuiComponents, materialControlElements, materialTranslations, useMuiComponents };
//# sourceMappingURL=react-querybuilder_material.legacy-esm.js.map