@rjsf/mui
Version:
Material UI 7 theme, fields and widgets for react-jsonschema-form
1,332 lines (1,301 loc) • 50.1 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var index_exports = {};
__export(index_exports, {
Form: () => MuiForm_default,
Templates: () => Templates_default,
Theme: () => Theme_default,
Widgets: () => Widgets_default,
default: () => index_default,
generateForm: () => generateForm,
generateTemplates: () => generateTemplates,
generateTheme: () => generateTheme,
generateWidgets: () => generateWidgets
});
module.exports = __toCommonJS(index_exports);
// src/MuiForm/MuiForm.tsx
var import_core4 = require("@rjsf/core");
// src/AddButton/AddButton.tsx
var import_Add = __toESM(require("@mui/icons-material/Add"), 1);
var import_IconButton = __toESM(require("@mui/material/IconButton"), 1);
var import_utils = require("@rjsf/utils");
// src/util.ts
function getMuiProps(options, propsToFilter, rjsfSlotPropsOnly) {
const muiProps = options?.mui || {};
if (rjsfSlotPropsOnly) {
const { rjsfSlotProps } = muiProps;
return { rjsfSlotProps };
}
if (propsToFilter) {
return Object.keys(muiProps).filter((key) => propsToFilter.includes(key)).reduce((obj, key) => {
obj[key] = muiProps[key];
return obj;
}, {});
}
return muiProps;
}
function computeSxProps(sxProps, muiProps) {
if (!muiProps) {
return sxProps;
}
if (Array.isArray(muiProps?.sx)) {
return [sxProps, ...muiProps.sx];
}
return { ...sxProps, ...muiProps?.sx };
}
// src/AddButton/AddButton.tsx
var import_jsx_runtime = require("react/jsx-runtime");
function AddButton({
uiSchema,
registry,
...props
}) {
const { translateString } = registry;
const uiOptions = (0, import_utils.getUiOptions)(uiSchema);
const muiProps = getMuiProps(uiOptions, [
"color",
"disableFocusRipple",
"disableRipple",
"edge",
"size",
"sx"
]);
return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_IconButton.default, { title: translateString(import_utils.TranslatableString.AddItemButton), ...props, color: "primary", ...muiProps, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Add.default, {}) });
}
// src/ArrayFieldItemTemplate/ArrayFieldItemTemplate.tsx
var import_Box = __toESM(require("@mui/material/Box"), 1);
var import_Grid = __toESM(require("@mui/material/Grid"), 1);
var import_Paper = __toESM(require("@mui/material/Paper"), 1);
var import_utils2 = require("@rjsf/utils");
var import_jsx_runtime2 = require("react/jsx-runtime");
function ArrayFieldItemTemplate(props) {
const { children, buttonsProps, hasDescription, hasToolbar, uiSchema, registry } = props;
const uiOptions = (0, import_utils2.getUiOptions)(uiSchema);
const ArrayFieldItemButtonsTemplate = (0, import_utils2.getTemplate)(
"ArrayFieldItemButtonsTemplate",
registry,
uiOptions
);
const btnStyle = {
flex: 1,
paddingLeft: 6,
paddingRight: 6,
fontWeight: "bold",
minWidth: 0
};
const {
rjsfSlotProps: {
arrayItemGridContainer,
arrayItemGridItem,
arrayItemInnerBox,
arrayItemOuterBox,
arrayItemPaper,
arrayItemToolbarGrid
} = {}
} = getMuiProps(uiOptions);
return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
import_Grid.default,
{
container: true,
...arrayItemGridContainer,
sx: computeSxProps({ alignItems: "center" }, arrayItemGridContainer),
children: [
/* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
import_Grid.default,
{
size: { xs: 8, sm: 9, md: 10, lg: 11, xl: 11.25 },
...arrayItemGridItem,
sx: computeSxProps({ overflow: "auto" }, arrayItemGridItem),
children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_Box.default, { ...arrayItemOuterBox, sx: computeSxProps({ mb: 2 }, arrayItemOuterBox), children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_Paper.default, { elevation: 2, ...arrayItemPaper, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_Box.default, { ...arrayItemInnerBox, sx: computeSxProps({ p: 2 }, arrayItemInnerBox), children }) }) })
}
),
hasToolbar && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
import_Grid.default,
{
...arrayItemToolbarGrid,
sx: computeSxProps({ mt: hasDescription ? -5 : -1.5 }, arrayItemToolbarGrid),
children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ArrayFieldItemButtonsTemplate, { ...buttonsProps, style: btnStyle })
}
)
]
}
);
}
// src/ArrayFieldTemplate/ArrayFieldTemplate.tsx
var import_Box2 = __toESM(require("@mui/material/Box"), 1);
var import_Grid2 = __toESM(require("@mui/material/Grid"), 1);
var import_Paper2 = __toESM(require("@mui/material/Paper"), 1);
var import_utils3 = require("@rjsf/utils");
var import_jsx_runtime3 = require("react/jsx-runtime");
function ArrayFieldTemplate(props) {
const {
canAdd,
disabled,
fieldPathId,
uiSchema,
items,
optionalDataControl,
onAddClick,
readonly,
registry,
required,
schema,
title
} = props;
const uiOptions = (0, import_utils3.getUiOptions)(uiSchema);
const ArrayFieldDescriptionTemplate = (0, import_utils3.getTemplate)(
"ArrayFieldDescriptionTemplate",
registry,
uiOptions
);
const ArrayFieldTitleTemplate = (0, import_utils3.getTemplate)(
"ArrayFieldTitleTemplate",
registry,
uiOptions
);
const showOptionalDataControlInTitle = !readonly && !disabled;
const {
ButtonTemplates: { AddButton: AddButton2 }
} = registry.templates;
const {
rjsfSlotProps: {
arrayPaper,
arrayBox,
arrayAddButtonGridContainer,
arrayAddButtonGridItem,
arrayAddButtonBox
} = {}
} = getMuiProps(uiOptions);
return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_Paper2.default, { elevation: 2, ...arrayPaper, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_Box2.default, { ...arrayBox, sx: computeSxProps({ p: 2 }, arrayBox), children: [
/* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
ArrayFieldTitleTemplate,
{
fieldPathId,
title: uiOptions.title || title,
schema,
uiSchema,
required,
registry,
optionalDataControl: showOptionalDataControlInTitle ? optionalDataControl : void 0
}
),
/* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
ArrayFieldDescriptionTemplate,
{
fieldPathId,
description: uiOptions.description || schema.description,
schema,
uiSchema,
registry
}
),
!showOptionalDataControlInTitle ? optionalDataControl : void 0,
items,
canAdd && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
import_Grid2.default,
{
container: true,
...arrayAddButtonGridContainer,
sx: computeSxProps({ justifyContent: "flex-end" }, arrayAddButtonGridContainer),
children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_Grid2.default, { ...arrayAddButtonGridItem, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_Box2.default, { ...arrayAddButtonBox, sx: computeSxProps({ mt: 2 }, arrayAddButtonBox), children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
AddButton2,
{
id: (0, import_utils3.buttonId)(fieldPathId, "add"),
className: "rjsf-array-item-add",
onClick: onAddClick,
disabled: disabled || readonly,
uiSchema,
registry
}
) }) })
}
)
] }) });
}
// src/BaseInputTemplate/BaseInputTemplate.tsx
var import_react = require("react");
var import_TextField = __toESM(require("@mui/material/TextField"), 1);
var import_InputAdornment = __toESM(require("@mui/material/InputAdornment"), 1);
var import_utils4 = require("@rjsf/utils");
var import_core = require("@rjsf/core");
var import_jsx_runtime4 = require("react/jsx-runtime");
var TYPES_THAT_SHRINK_LABEL = ["date", "datetime-local", "file", "time"];
function BaseInputTemplate(props) {
const {
id,
name,
// remove this from textFieldProps
htmlName,
placeholder,
required,
readonly,
disabled,
type,
label,
hideLabel,
hideError,
value,
onChange,
onChangeOverride,
onBlur,
onFocus,
autofocus,
options,
schema,
uiSchema,
rawErrors = [],
errorSchema,
registry,
InputLabelProps,
InputProps,
slotProps,
...textFieldProps
} = props;
const { ClearButton: ClearButton2 } = registry.templates.ButtonTemplates;
const { step, min, max, accept, ...rest } = (0, import_utils4.getInputProps)(schema, type, options);
const muiProps = getMuiProps(options);
const { slotProps: muiSlotProps, ...otherMuiProps } = muiProps;
const htmlInputProps = {
...slotProps?.htmlInput,
...muiSlotProps?.htmlInput,
step,
min,
max,
accept,
...schema.examples ? { list: (0, import_utils4.examplesId)(id) } : void 0
};
const _onChange = ({ target: { value: value2 } }) => onChange(value2 === "" ? options.emptyValue : value2);
const _onBlur = ({ target }) => onBlur(id, target && target.value);
const _onFocus = ({ target }) => onFocus(id, target && target.value);
const DisplayInputLabelProps = TYPES_THAT_SHRINK_LABEL.includes(type) ? { ...slotProps?.inputLabel, ...muiSlotProps?.inputLabel, ...InputLabelProps, shrink: true } : { ...slotProps?.inputLabel, ...muiSlotProps?.inputLabel, ...InputLabelProps };
const _onClear = (0, import_react.useCallback)(
(e) => {
e.preventDefault();
e.stopPropagation();
onChange(options.emptyValue ?? "");
},
[onChange, options.emptyValue]
);
const inputProps = { ...InputProps, ...slotProps?.input, ...muiSlotProps?.input };
if (options.allowClearTextInputs && value && !readonly && !disabled) {
const clearAdornment = /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_InputAdornment.default, { position: "end", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ClearButton2, { registry, onClick: _onClear }) });
inputProps.endAdornment = !inputProps.endAdornment ? clearAdornment : /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
inputProps.endAdornment,
clearAdornment
] });
}
return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
/* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
import_TextField.default,
{
id,
name: htmlName || id,
placeholder,
label: (0, import_utils4.labelValue)(label || void 0, hideLabel, void 0),
autoFocus: autofocus,
required,
disabled: disabled || readonly,
slotProps: {
...slotProps,
...muiSlotProps,
input: inputProps,
htmlInput: htmlInputProps,
inputLabel: DisplayInputLabelProps
},
...rest,
value: value || value === 0 ? value : "",
error: rawErrors.length > 0,
onChange: onChangeOverride || _onChange,
onBlur: _onBlur,
onFocus: _onFocus,
...{ ...otherMuiProps, ...textFieldProps },
"aria-describedby": (0, import_utils4.ariaDescribedByIds)(id, !!schema.examples)
}
),
/* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_core.SchemaExamples, { id, schema })
] });
}
// src/DescriptionField/DescriptionField.tsx
var import_Typography = __toESM(require("@mui/material/Typography"), 1);
var import_utils5 = require("@rjsf/utils");
var import_core2 = require("@rjsf/core");
var import_jsx_runtime5 = require("react/jsx-runtime");
function DescriptionField(props) {
const { id, description, registry, uiSchema } = props;
const uiOptions = (0, import_utils5.getUiOptions)(uiSchema);
const { rjsfSlotProps: { descTypography } = {} } = getMuiProps(uiOptions);
if (description) {
return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
import_Typography.default,
{
id,
variant: "subtitle2",
...descTypography,
sx: computeSxProps({ mt: 0.625 }, descTypography),
children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_core2.RichDescription, { description, registry, uiSchema })
}
);
}
return null;
}
// src/ErrorList/ErrorList.tsx
var import_Error = __toESM(require("@mui/icons-material/Error"), 1);
var import_Box3 = __toESM(require("@mui/material/Box"), 1);
var import_List = __toESM(require("@mui/material/List"), 1);
var import_ListItem = __toESM(require("@mui/material/ListItem"), 1);
var import_ListItemIcon = __toESM(require("@mui/material/ListItemIcon"), 1);
var import_ListItemText = __toESM(require("@mui/material/ListItemText"), 1);
var import_Paper3 = __toESM(require("@mui/material/Paper"), 1);
var import_Typography2 = __toESM(require("@mui/material/Typography"), 1);
var import_utils6 = require("@rjsf/utils");
var import_jsx_runtime6 = require("react/jsx-runtime");
function ErrorList({
errors,
registry,
uiSchema
}) {
const { translateString } = registry;
const uiOptions = (0, import_utils6.getUiOptions)(uiSchema);
const {
rjsfSlotProps: {
errorPaper,
errorBox,
errorTypography,
errorList,
errorListItem,
errorListItemIcon,
errorListItemText
} = {}
} = getMuiProps(uiOptions);
return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_Paper3.default, { elevation: 2, ...errorPaper, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_Box3.default, { ...errorBox, sx: computeSxProps({ mb: 2, p: 2 }, errorBox), children: [
/* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_Typography2.default, { variant: "h6", ...errorTypography, children: translateString(import_utils6.TranslatableString.ErrorsLabel) }),
/* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_List.default, { dense: true, ...errorList, children: errors.map((error, i) => {
return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_ListItem.default, { ...errorListItem, children: [
/* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_ListItemIcon.default, { ...errorListItemIcon, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_Error.default, { color: "error" }) }),
/* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_ListItemText.default, { primary: error.stack, ...errorListItemText })
] }, i);
}) })
] }) });
}
// src/IconButton/IconButton.tsx
var import_IconButton2 = __toESM(require("@mui/material/IconButton"), 1);
var import_ArrowDownward = __toESM(require("@mui/icons-material/ArrowDownward"), 1);
var import_ArrowUpward = __toESM(require("@mui/icons-material/ArrowUpward"), 1);
var import_ContentCopy = __toESM(require("@mui/icons-material/ContentCopy"), 1);
var import_Remove = __toESM(require("@mui/icons-material/Remove"), 1);
var import_Clear = __toESM(require("@mui/icons-material/Clear"), 1);
var import_utils7 = require("@rjsf/utils");
var import_jsx_runtime7 = require("react/jsx-runtime");
function MuiIconButton(props) {
const { icon, color, uiSchema, registry, ...otherProps } = props;
const uiOptions = (0, import_utils7.getUiOptions)(uiSchema);
const muiProps = getMuiProps(uiOptions, [
"color",
"disableFocusRipple",
"disableRipple",
"edge",
"size",
"sx"
]);
return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_IconButton2.default, { ...muiProps, ...otherProps, size: "small", color, children: icon });
}
function CopyButton(props) {
const {
registry: { translateString }
} = props;
return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
MuiIconButton,
{
title: translateString(import_utils7.TranslatableString.CopyButton),
...props,
icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ContentCopy.default, { fontSize: "small" })
}
);
}
function MoveDownButton(props) {
const {
registry: { translateString }
} = props;
return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
MuiIconButton,
{
title: translateString(import_utils7.TranslatableString.MoveDownButton),
...props,
icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ArrowDownward.default, { fontSize: "small" })
}
);
}
function MoveUpButton(props) {
const {
registry: { translateString }
} = props;
return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
MuiIconButton,
{
title: translateString(import_utils7.TranslatableString.MoveUpButton),
...props,
icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ArrowUpward.default, { fontSize: "small" })
}
);
}
function RemoveButton(props) {
const { iconType, ...otherProps } = props;
const {
registry: { translateString }
} = otherProps;
return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
MuiIconButton,
{
title: translateString(import_utils7.TranslatableString.RemoveButton),
...otherProps,
color: "error",
icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_Remove.default, { fontSize: iconType === "default" ? void 0 : "small" })
}
);
}
function ClearButton(props) {
const { iconType, ...otherProps } = props;
const {
registry: { translateString }
} = otherProps;
return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
MuiIconButton,
{
title: translateString(import_utils7.TranslatableString.ClearButton),
...otherProps,
icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_Clear.default, { fontSize: iconType === "default" ? void 0 : "small" })
}
);
}
// src/FieldErrorTemplate/FieldErrorTemplate.tsx
var import_ListItem2 = __toESM(require("@mui/material/ListItem"), 1);
var import_FormHelperText = __toESM(require("@mui/material/FormHelperText"), 1);
var import_List2 = __toESM(require("@mui/material/List"), 1);
var import_utils8 = require("@rjsf/utils");
var import_jsx_runtime8 = require("react/jsx-runtime");
function FieldErrorTemplate(props) {
const { errors = [], fieldPathId, uiSchema } = props;
if (errors.length === 0) {
return null;
}
const id = (0, import_utils8.errorId)(fieldPathId);
const uiOptions = (0, import_utils8.getUiOptions)(uiSchema);
const muiProps = getMuiProps(uiOptions);
const { rjsfSlotProps: muiSlotProps } = muiProps;
return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_List2.default, { id, dense: true, disablePadding: true, ...muiSlotProps?.fieldErrorList, children: errors.map((error, i) => {
return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ListItem2.default, { disableGutters: true, ...muiSlotProps?.fieldErrorListItem, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_FormHelperText.default, { component: "div", id: `${id}-${i}`, ...muiSlotProps?.fieldErrorFormHelperText, children: error }) }, i);
}) });
}
// src/FieldHelpTemplate/FieldHelpTemplate.tsx
var import_core3 = require("@rjsf/core");
var import_utils9 = require("@rjsf/utils");
var import_FormHelperText2 = __toESM(require("@mui/material/FormHelperText"), 1);
var import_jsx_runtime9 = require("react/jsx-runtime");
function FieldHelpTemplate(props) {
const { fieldPathId, help, uiSchema, registry } = props;
if (!help) {
return null;
}
const uiOptions = (0, import_utils9.getUiOptions)(uiSchema);
const { rjsfSlotProps: { helpFormHelperText } = {} } = getMuiProps(uiOptions);
return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
import_FormHelperText2.default,
{
component: "div",
id: (0, import_utils9.helpId)(fieldPathId),
...helpFormHelperText,
sx: computeSxProps({ mt: 0.625 }, helpFormHelperText),
children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_core3.RichHelp, { help, registry, uiSchema })
}
);
}
// src/FieldTemplate/FieldTemplate.tsx
var import_FormControl = __toESM(require("@mui/material/FormControl"), 1);
var import_Typography3 = __toESM(require("@mui/material/Typography"), 1);
var import_utils10 = require("@rjsf/utils");
var import_jsx_runtime10 = require("react/jsx-runtime");
function FieldTemplate(props) {
const {
id,
children,
classNames,
style,
disabled,
displayLabel,
hidden,
label,
onKeyRename,
onKeyRenameBlur,
onRemoveProperty,
readonly,
required,
rawErrors = [],
errors,
help,
description,
rawDescription,
schema,
uiSchema,
registry
} = props;
const uiOptions = (0, import_utils10.getUiOptions)(uiSchema);
const WrapIfAdditionalTemplate2 = (0, import_utils10.getTemplate)(
"WrapIfAdditionalTemplate",
registry,
uiOptions
);
if (hidden) {
return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { style: { display: "none" }, children });
}
const isCheckbox = uiOptions.widget === "checkbox";
const { rjsfSlotProps: muiSlotProps, ...otherMuiProps } = getMuiProps(uiOptions);
return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
WrapIfAdditionalTemplate2,
{
classNames,
style,
disabled,
id,
label,
displayLabel,
rawDescription,
onKeyRename,
onKeyRenameBlur,
onRemoveProperty,
readonly,
required,
schema,
uiSchema,
registry,
children: /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(
import_FormControl.default,
{
fullWidth: true,
error: rawErrors.length ? true : false,
required,
...muiSlotProps?.fieldFormControl,
sx: otherMuiProps.sx,
className: otherMuiProps.className,
children: [
children,
displayLabel && !isCheckbox && rawDescription ? /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_Typography3.default, { variant: "caption", color: "textSecondary", ...muiSlotProps?.fieldTypography, children: description }) : null,
errors,
help
]
}
)
}
);
}
// src/GridTemplate/GridTemplate.tsx
var import_Grid3 = __toESM(require("@mui/material/Grid"), 1);
var import_jsx_runtime11 = require("react/jsx-runtime");
function GridTemplate(props) {
const { children, column, ...rest } = props;
return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_Grid3.default, { container: !column, ...rest, children });
}
// src/MultiSchemaFieldTemplate/MultiSchemaFieldTemplate.tsx
var import_Box4 = __toESM(require("@mui/material/Box"), 1);
var import_FormControl2 = __toESM(require("@mui/material/FormControl"), 1);
var import_utils11 = require("@rjsf/utils");
var import_jsx_runtime12 = require("react/jsx-runtime");
function MultiSchemaFieldTemplate(props) {
const { optionSchemaField, selector, uiSchema } = props;
const uiOptions = (0, import_utils11.getUiOptions)(uiSchema);
const { rjsfSlotProps: muiSlotProps } = getMuiProps(uiOptions);
return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_Box4.default, { sx: { mb: 2 }, ...muiSlotProps?.multiBox, children: [
/* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_FormControl2.default, { fullWidth: true, sx: { mb: 2 }, ...muiSlotProps?.multiFormControl, children: selector }),
optionSchemaField
] });
}
// src/ObjectFieldTemplate/ObjectFieldTemplate.tsx
var import_Grid4 = __toESM(require("@mui/material/Grid"), 1);
var import_utils12 = require("@rjsf/utils");
var import_jsx_runtime13 = require("react/jsx-runtime");
function ObjectFieldTemplate(props) {
const {
description,
title,
properties,
required,
disabled,
readonly,
uiSchema,
fieldPathId,
schema,
formData,
optionalDataControl,
onAddProperty,
registry
} = props;
const uiOptions = (0, import_utils12.getUiOptions)(uiSchema);
const TitleFieldTemplate = (0, import_utils12.getTemplate)("TitleFieldTemplate", registry, uiOptions);
const DescriptionFieldTemplate = (0, import_utils12.getTemplate)(
"DescriptionFieldTemplate",
registry,
uiOptions
);
const showOptionalDataControlInTitle = !readonly && !disabled;
const {
ButtonTemplates: { AddButton: AddButton2 }
} = registry.templates;
const {
rjsfSlotProps: { objectGridContainer, objectGridItem, objectAddButtonGridContainer, objectAddButtonGridItem } = {}
} = getMuiProps(uiOptions);
return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_jsx_runtime13.Fragment, { children: [
title && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
TitleFieldTemplate,
{
id: (0, import_utils12.titleId)(fieldPathId),
title,
required,
schema,
uiSchema,
registry,
optionalDataControl: showOptionalDataControlInTitle ? optionalDataControl : void 0
}
),
description && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
DescriptionFieldTemplate,
{
id: (0, import_utils12.descriptionId)(fieldPathId),
description,
schema,
uiSchema,
registry
}
),
/* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
import_Grid4.default,
{
container: true,
spacing: 2,
...objectGridContainer,
sx: computeSxProps({ mt: 1.25 }, objectGridContainer),
children: [
!showOptionalDataControlInTitle ? optionalDataControl : void 0,
properties.map(
(element, index) => (
// Remove the <Grid> if the inner element is hidden as the <Grid>
// itself would otherwise still take up space.
element.hidden ? element.content : /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
import_Grid4.default,
{
size: { xs: 12 },
...objectGridItem,
sx: computeSxProps({ mb: 1.25 }, objectGridItem),
children: element.content
},
index
)
)
)
]
}
),
(0, import_utils12.canExpand)(schema, uiSchema, formData) && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
import_Grid4.default,
{
container: true,
...objectAddButtonGridContainer,
sx: computeSxProps({ justifyContent: "flex-end" }, objectAddButtonGridContainer),
children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_Grid4.default, { ...objectAddButtonGridItem, children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
AddButton2,
{
id: (0, import_utils12.buttonId)(fieldPathId, "add"),
className: "rjsf-object-property-expand",
onClick: onAddProperty,
disabled: disabled || readonly,
uiSchema,
registry
}
) })
}
)
] });
}
// src/OptionalDataControlsTemplate/OptionalDataControlsTemplate.tsx
var import_Add2 = __toESM(require("@mui/icons-material/Add"), 1);
var import_jsx_runtime14 = require("react/jsx-runtime");
function OptionalDataControlsTemplate(props) {
const { id, registry, label, onAddClick, onRemoveClick, uiSchema } = props;
if (onAddClick) {
return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
MuiIconButton,
{
id,
registry,
uiSchema,
className: "rjsf-add-optional-data",
onClick: onAddClick,
title: label,
icon: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_Add2.default, { fontSize: "small" })
}
);
} else if (onRemoveClick) {
return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
RemoveButton,
{
id,
registry,
uiSchema,
className: "rjsf-remove-optional-data",
onClick: onRemoveClick,
title: label
}
);
}
return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("em", { id, children: label });
}
// src/SubmitButton/SubmitButton.tsx
var import_Box5 = __toESM(require("@mui/material/Box"), 1);
var import_Button = __toESM(require("@mui/material/Button"), 1);
var import_utils13 = require("@rjsf/utils");
var import_jsx_runtime15 = require("react/jsx-runtime");
function SubmitButton({ uiSchema }) {
const { submitText, norender, props: submitButtonProps = {} } = (0, import_utils13.getSubmitButtonOptions)(uiSchema);
if (norender) {
return null;
}
const uiOptions = (0, import_utils13.getUiOptions)(uiSchema);
const { rjsfSlotProps: { submitBox, submitButton } = {}, ...otherMuiProps } = getMuiProps(uiOptions);
return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_Box5.default, { ...submitBox, sx: computeSxProps({ mt: 3 }, submitBox), children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
import_Button.default,
{
type: "submit",
variant: "contained",
color: "primary",
...submitButtonProps,
...otherMuiProps,
...submitButton,
children: submitText
}
) });
}
// src/TitleField/TitleField.tsx
var import_Box6 = __toESM(require("@mui/material/Box"), 1);
var import_Divider = __toESM(require("@mui/material/Divider"), 1);
var import_Grid5 = __toESM(require("@mui/material/Grid"), 1);
var import_Typography4 = __toESM(require("@mui/material/Typography"), 1);
var import_utils14 = require("@rjsf/utils");
var import_jsx_runtime16 = require("react/jsx-runtime");
function TitleField(props) {
const { id, title, optionalDataControl, uiSchema } = props;
const uiOptions = (0, import_utils14.getUiOptions)(uiSchema);
const {
rjsfSlotProps: {
titleBox,
titleDivider,
titleTypography,
titleGridContainer,
titleGridItem,
titleOptionalDataGridItem
} = {}
} = getMuiProps(uiOptions);
let heading = /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_Typography4.default, { variant: "h5", ...titleTypography, children: title });
if (optionalDataControl) {
heading = /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_Grid5.default, { container: true, spacing: 0, ...titleGridContainer, children: [
/* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_Grid5.default, { size: "grow", ...titleGridItem, children: heading }),
/* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
import_Grid5.default,
{
...titleOptionalDataGridItem,
sx: computeSxProps({ justifyContent: "flex-end" }, titleOptionalDataGridItem),
children: optionalDataControl
}
)
] });
}
return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_Box6.default, { id, ...titleBox, sx: computeSxProps({ mb: 1, mt: 1 }, titleBox), children: [
heading,
/* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_Divider.default, { ...titleDivider })
] });
}
// src/WrapIfAdditionalTemplate/WrapIfAdditionalTemplate.tsx
var import_Grid6 = __toESM(require("@mui/material/Grid"), 1);
var import_TextField2 = __toESM(require("@mui/material/TextField"), 1);
var import_utils15 = require("@rjsf/utils");
var import_jsx_runtime17 = require("react/jsx-runtime");
function WrapIfAdditionalTemplate(props) {
const {
children,
classNames,
style,
disabled,
id,
label,
displayLabel,
onKeyRenameBlur,
onRemoveProperty,
readonly,
required,
schema,
uiSchema,
registry
} = props;
const { templates, translateString } = registry;
const { RemoveButton: RemoveButton2 } = templates.ButtonTemplates;
const keyLabel = translateString(import_utils15.TranslatableString.KeyLabel, [label]);
const additional = import_utils15.ADDITIONAL_PROPERTY_FLAG in schema;
const btnStyle = {
flex: 1,
paddingLeft: 6,
paddingRight: 6,
fontWeight: "bold"
};
const uiOptions = (0, import_utils15.getUiOptions)(uiSchema);
const { rjsfSlotProps: { wrapGridContainer, wrapKeyGridItem, wrapChildrenGridItem, wrapRemoveButtonGridItem } = {} } = getMuiProps(uiOptions);
if (!additional) {
return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { className: classNames, style, children });
}
return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(
import_Grid6.default,
{
container: true,
spacing: 2,
className: classNames,
style,
...wrapGridContainer,
sx: computeSxProps({ alignItems: "flex-start" }, wrapGridContainer),
children: [
/* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_Grid6.default, { size: 5.5, ...wrapKeyGridItem, children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
import_TextField2.default,
{
fullWidth: true,
required,
label: displayLabel ? keyLabel : void 0,
defaultValue: label,
disabled: disabled || readonly,
id: `${id}-key`,
name: `${id}-key`,
onBlur: !readonly ? onKeyRenameBlur : void 0,
type: "text"
},
label
) }),
/* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_Grid6.default, { size: 5.5, ...wrapChildrenGridItem, children }),
/* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_Grid6.default, { ...wrapRemoveButtonGridItem, sx: computeSxProps({ mt: 1.5 }, wrapRemoveButtonGridItem), children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
RemoveButton2,
{
id: (0, import_utils15.buttonId)(id, "remove"),
className: "rjsf-object-property-remove",
iconType: "default",
style: btnStyle,
disabled: disabled || readonly,
onClick: onRemoveProperty,
uiSchema,
registry
}
) })
]
},
`${id}-key`
);
}
// src/Templates/Templates.ts
function generateTemplates() {
return {
ArrayFieldItemTemplate,
ArrayFieldTemplate,
BaseInputTemplate,
ButtonTemplates: {
AddButton,
CopyButton,
MoveDownButton,
MoveUpButton,
RemoveButton,
SubmitButton,
ClearButton
},
DescriptionFieldTemplate: DescriptionField,
ErrorListTemplate: ErrorList,
FieldErrorTemplate,
FieldHelpTemplate,
FieldTemplate,
GridTemplate,
MultiSchemaFieldTemplate,
ObjectFieldTemplate,
OptionalDataControlsTemplate,
TitleFieldTemplate: TitleField,
WrapIfAdditionalTemplate
};
}
var Templates_default = generateTemplates();
// src/CheckboxWidget/CheckboxWidget.tsx
var import_Checkbox = __toESM(require("@mui/material/Checkbox"), 1);
var import_FormControlLabel = __toESM(require("@mui/material/FormControlLabel"), 1);
var import_utils16 = require("@rjsf/utils");
var import_jsx_runtime18 = require("react/jsx-runtime");
function CheckboxWidget(props) {
const {
schema,
id,
htmlName,
value,
disabled,
readonly,
label = "",
hideLabel,
autofocus,
onChange,
onBlur,
onFocus,
registry,
options,
uiSchema
} = props;
const DescriptionFieldTemplate = (0, import_utils16.getTemplate)(
"DescriptionFieldTemplate",
registry,
options
);
const required = (0, import_utils16.schemaRequiresTrueValue)(schema);
const _onChange = (_, checked) => onChange(checked);
const _onBlur = () => onBlur(id, value);
const _onFocus = () => onFocus(id, value);
const description = options.description ?? schema.description;
const { rjsfSlotProps: muiSlotProps, ...otherMuiProps } = getMuiProps(options);
return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_jsx_runtime18.Fragment, { children: [
!hideLabel && description && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
DescriptionFieldTemplate,
{
id: (0, import_utils16.descriptionId)(id),
description,
schema,
uiSchema,
registry
}
),
/* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
import_FormControlLabel.default,
{
...otherMuiProps,
...muiSlotProps?.formControlLabel,
control: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
import_Checkbox.default,
{
id,
name: htmlName || id,
checked: typeof value === "undefined" ? false : Boolean(value),
required,
disabled: disabled || readonly,
autoFocus: autofocus,
onChange: _onChange,
onBlur: _onBlur,
onFocus: _onFocus,
"aria-describedby": (0, import_utils16.ariaDescribedByIds)(id),
...muiSlotProps?.checkbox
}
),
label: (0, import_utils16.labelValue)(label, hideLabel, false)
}
)
] });
}
// src/CheckboxesWidget/CheckboxesWidget.tsx
var import_Checkbox2 = __toESM(require("@mui/material/Checkbox"), 1);
var import_FormControlLabel2 = __toESM(require("@mui/material/FormControlLabel"), 1);
var import_FormGroup = __toESM(require("@mui/material/FormGroup"), 1);
var import_FormLabel = __toESM(require("@mui/material/FormLabel"), 1);
var import_utils17 = require("@rjsf/utils");
var import_jsx_runtime19 = require("react/jsx-runtime");
var import_react2 = require("react");
function CheckboxesWidget(props) {
const {
label,
hideLabel,
id,
htmlName,
disabled,
options,
value,
autofocus,
readonly,
required,
onChange,
onBlur,
onFocus
} = props;
const { enumOptions, enumDisabled, inline, emptyValue } = options;
const optionValueFormat = (0, import_utils17.getOptionValueFormat)(options);
const checkboxesValues = Array.isArray(value) ? value : [value];
const _onChange = (index) => ({ target: { checked } }) => {
if (checked) {
onChange((0, import_utils17.enumOptionsSelectValue)(index, checkboxesValues, enumOptions));
} else {
onChange((0, import_utils17.enumOptionsDeselectValue)(index, checkboxesValues, enumOptions));
}
};
const _onBlur = ({ target }) => onBlur(id, (0, import_utils17.enumOptionValueDecoder)(target && target.value, enumOptions, optionValueFormat, emptyValue));
const _onFocus = ({ target }) => onFocus(id, (0, import_utils17.enumOptionValueDecoder)(target && target.value, enumOptions, optionValueFormat, emptyValue));
const { rjsfSlotProps: muiSlotProps, ...otherMuiProps } = getMuiProps(options);
return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_jsx_runtime19.Fragment, { children: [
(0, import_utils17.labelValue)(
/* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_FormLabel.default, { required, htmlFor: id, children: label || void 0 }),
hideLabel
),
/* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_FormGroup.default, { ...otherMuiProps, ...muiSlotProps?.formGroup, id, row: !!inline, children: Array.isArray(enumOptions) && enumOptions.map((option, index) => {
const checked = (0, import_utils17.enumOptionsIsSelected)(option.value, checkboxesValues);
const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) !== -1;
const checkbox = /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
import_Checkbox2.default,
{
...muiSlotProps?.checkbox,
id: (0, import_utils17.optionId)(id, index),
name: htmlName || id,
checked,
disabled: disabled || itemDisabled || readonly,
autoFocus: autofocus && index === 0,
onChange: _onChange(index),
onBlur: _onBlur,
onFocus: _onFocus,
"aria-describedby": (0, import_utils17.ariaDescribedByIds)(id)
}
);
return /* @__PURE__ */ (0, import_react2.createElement)(
import_FormControlLabel2.default,
{
...muiSlotProps?.formControlLabel,
control: checkbox,
key: index,
label: option.label
}
);
}) })
] });
}
// src/RadioWidget/RadioWidget.tsx
var import_FormControlLabel3 = __toESM(require("@mui/material/FormControlLabel"), 1);
var import_FormLabel2 = __toESM(require("@mui/material/FormLabel"), 1);
var import_Radio = __toESM(require("@mui/material/Radio"), 1);
var import_RadioGroup = __toESM(require("@mui/material/RadioGroup"), 1);
var import_utils18 = require("@rjsf/utils");
var import_jsx_runtime20 = require("react/jsx-runtime");
var import_react3 = require("react");
function RadioWidget(props) {
const { id, htmlName, options, value, required, disabled, readonly, label, hideLabel, onChange, onBlur, onFocus } = props;
const { enumOptions, enumDisabled, emptyValue } = options;
const optionValueFormat = (0, import_utils18.getOptionValueFormat)(options);
const _onChange = (_, value2) => onChange((0, import_utils18.enumOptionValueDecoder)(value2, enumOptions, optionValueFormat, emptyValue));
const _onBlur = ({ target }) => onBlur(id, (0, import_utils18.enumOptionValueDecoder)(target && target.value, enumOptions, optionValueFormat, emptyValue));
const _onFocus = ({ target }) => onFocus(id, (0, import_utils18.enumOptionValueDecoder)(target && target.value, enumOptions, optionValueFormat, emptyValue));
const row = options ? options.inline : false;
const selectValue = (0, import_utils18.enumOptionSelectedValue)(value, enumOptions, false, optionValueFormat, "");
const { rjsfSlotProps: muiSlotProps, ...otherMuiProps } = getMuiProps(options);
return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_jsx_runtime20.Fragment, { children: [
(0, import_utils18.labelValue)(
/* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_FormLabel2.default, { required, htmlFor: id, children: label || void 0 }),
hideLabel
),
/* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
import_RadioGroup.default,
{
...otherMuiProps,
...muiSlotProps?.radioGroup,
id,
name: htmlName || id,
value: selectValue,
row,
onChange: _onChange,
onBlur: _onBlur,
onFocus: _onFocus,
"aria-describedby": (0, import_utils18.ariaDescribedByIds)(id),
children: Array.isArray(enumOptions) && enumOptions.map((option, index) => {
const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) !== -1;
const radio = /* @__PURE__ */ (0, import_react3.createElement)(
import_FormControlLabel3.default,
{
...muiSlotProps?.formControlLabel,
control: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_Radio.default, { ...muiSlotProps?.radio, name: htmlName || id, id: (0, import_utils18.optionId)(id, index), color: "primary" }),
label: option.label,
value: (0, import_utils18.enumOptionValueEncoder)(option.value, index, optionValueFormat),
key: index,
disabled: disabled || itemDisabled || readonly
}
);
return radio;
})
}
)
] });
}
// src/RangeWidget/RangeWidget.tsx
var import_FormLabel3 = __toESM(require("@mui/material/FormLabel"), 1);
var import_Slider = __toESM(require("@mui/material/Slider"), 1);
var import_utils19 = require("@rjsf/utils");
var import_jsx_runtime21 = require("react/jsx-runtime");
function RangeWidget(props) {
const { value, readonly, disabled, onBlur, onFocus, options, schema, onChange, required, label, hideLabel, id } = props;
const sliderProps = { value, label, id, name: id, ...(0, import_utils19.rangeSpec)(schema) };
const _onChange = (_, value2) => {
onChange(value2 ?? options.emptyValue);
};
const _onBlur = ({ target }) => onBlur(id, target && target.value);
const _onFocus = ({ target }) => onFocus(id, target && target.value);
const { rjsfSlotProps: muiSlotProps, ...otherMuiProps } = getMuiProps(options);
return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_jsx_runtime21.Fragment, { children: [
(0, import_utils19.labelValue)(
/* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_FormLabel3.default, { required, htmlFor: id, children: label || void 0 }),
hideLabel
),
/* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
import_Slider.default,
{
disabled: disabled || readonly,
onChange: _onChange,
onBlur: _onBlur,
onFocus: _onFocus,
valueLabelDisplay: "auto",
...otherMuiProps,
...muiSlotProps?.slider,
...sliderProps,
"aria-describedby": (0, import_utils19.ariaDescribedByIds)(id)
}
)
] });
}
// src/SelectWidget/SelectWidget.tsx
var import_MenuItem = __toESM(require("@mui/material/MenuItem"), 1);
var import_TextField3 = __toESM(require("@mui/material/TextField"), 1);
var import_utils20 = require("@rjsf/utils");
var import_jsx_runtime22 = require("react/jsx-runtime");
function SelectWidget(props) {
const {
schema,
id,
name,
// remove this from textFieldProps
htmlName,
options,
label,
hideLabel,
required,
disabled,
placeholder,
readonly,
value,
multiple,
autofocus,
onChange,
onBlur,
onFocus,
errorSchema,
rawErrors = [],
registry,
uiSchema,
hideError,
...textFieldProps
} = props;
const { enumOptions, enumDisabled, emptyValue: optEmptyVal } = options;
const optionValueFormat = (0, import_utils20.getOptionValueFormat)(options);
const isMultiple = typeof multiple === "undefined" ? false : !!multiple;
const emptyValue = isMultiple ? [] : "";
const isEmpty = typeof value === "undefined" || isMultiple && value.length < 1 || !isMultiple && value === emptyValue;
const _onChange = ({ target: { value: value2 } }) => onChange((0, import_utils20.enumOptionValueDecoder)(value2, enumOptions, optionValueFormat, optEmptyVal));
const _onBlur = ({ target }) => onBlur(id, (0, import_utils20.enumOptionValueDecoder)(target && target.value, enumOptions, optionValueFormat, optEmptyVal));
const _onFocus = ({ target }) => onFocus(id, (0, import_utils20.enumOptionValueDecoder)(target && target.value, enumOptions, optionValueFormat, optEmptyVal));
const { rjsfSlotProps: muiSlotProps, ...otherMuiProps } = getMuiProps(options);
const { InputLabelProps, SelectProps, autocomplete, ...textFieldRemainingProps } = textFieldProps;
const showPlaceholderOption = !isMultiple && schema.default === void 0;
return /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(
import_TextField3.default,
{
id,
name: htmlName || id,
label: (0, import_utils20.labelValue)(label || void 0, hideLabel, void 0),
value: (0, import_utils20.enumOptionSelectedValue)(value, enumOptions, isMultiple, optionValueFormat, emptyValue),
required,
disabled: disabled || readonly,
autoFocus: autofocus,
autoComplete: autocomplete,
placeholder,
error: rawErrors.length > 0,
onChange: _onChange,
onBlur: _onBlur,
onFocus: _onFocus,
...{ ...otherMuiProps, ...textFieldRemainingProps },
select: true,
slotProps: {
...muiSlotProps,
inputLabel: {
...muiSlotProps?.inputLabel,
shrink: !isEmpty
},
select: {
...muiSlotProps?.select,
multiple
}
},
"aria-describedby": (0, import_utils20.ariaDescribedByIds)(id),
children: [
showPlaceholderOption && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_MenuItem.default, { value: "", children: placeholder }),
Array.isArray(enumOptions) && enumOptions.map(({ value: value2, label: label2 }, i) => {
const disabled2 = Array.isArray(enumDisabled) && enumDisabled.indexOf(value2) !== -1;
return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_MenuItem.default, { value: (0, import_utils20.enumOptionValueEncoder)(value2, i, optionValueFormat), disabled: disabled2, children: label2 }, i);
})
]
}
);
}
// src/TextareaWidget/TextareaWidget.tsx
var import_utils21 = require("@rjsf/utils");
var import_jsx_runtime23 = require("react/jsx-runtime");
function TextareaWidget(props) {
const { options, registry } = props;
const BaseInputTemplate2 = (0, import_utils21.getTemplate)("BaseInputTemplate", registry, options);
let rows = 5;
if (typeof options.rows === "string" || typeof options.rows === "number") {
rows = options.rows;
}
return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(BaseInputTemplate2, { ...props, multiline: true, rows });
}
// src/Widgets/Widgets.ts
function generateWidgets() {
return {
CheckboxWidget,
CheckboxesWidget,
RadioWidget,
RangeWidget,
SelectWidget,
TextareaWidget
};
}
var Widgets_default = generateWidgets();
// src/Theme/Theme.tsx
function generateTheme() {
return {
templates: generateTemplates(),
widgets: generateWidgets()
};
}
var Theme_default = generateTheme();
// src/MuiForm/MuiForm.tsx
function generateForm() {
return (0, import_core4.withTheme)(generat