@lowentry/mui 1.4.4 → 2.0.1

package/dist/index.js

@@ -0,0 +1,720 @@
+// src/LeMuiUtils.ts
+import { LeUtils, STRING, INT_LAX } from "@lowentry/utils";
+var HIDDEN_CHAR = "\u200B";
+var LeMuiUtils = {
+  onSelectEnsureMinimumOffset: (charactersCount) => {
+    const count = Math.max(0, INT_LAX(charactersCount));
+    if (count <= 0) {
+      return () => {
+      };
+    }
+    return (event) => {
+      const target = event.target;
+      if (target && (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) && "selectionEnd" in target && "selectionStart" in target && "setSelectionRange" in target) {
+        const selectionEnd = target.selectionEnd ?? 0;
+        const selectionStart = target.selectionStart ?? 0;
+        if (selectionEnd < count) {
+          target.setSelectionRange(count, count);
+        } else if (selectionStart < count) {
+          target.setSelectionRange(count, selectionEnd);
+        }
+      }
+    };
+  },
+  prependHiddenChar: (string) => {
+    const str = STRING(string);
+    if (str.startsWith(HIDDEN_CHAR)) {
+      return str;
+    }
+    return HIDDEN_CHAR + str;
+  },
+  purgePrependedHiddenChar: (string) => {
+    const str = STRING(string);
+    return LeUtils.trimStart(str, ["\u200B", " ", "	", "\r", "\n"]);
+  }
+};
+
+// src/components/Avatar.tsx
+import { memo, useRetryingImageUrl, useCallback } from "@lowentry/react-redux";
+import MuiAvatar from "@mui/material/Avatar";
+import { jsx } from "react/jsx-runtime";
+var Avatar = memo(({ src, slotProps, retryOptions, children, ...props }) => {
+  const [imgSrc, onImgError] = useRetryingImageUrl(src ?? "", retryOptions ?? {});
+  const onError = useCallback(
+    (event) => {
+      onImgError();
+      if (slotProps?.img?.onError) {
+        slotProps.img.onError(event);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [onImgError, slotProps?.img?.onError]
+  );
+  return /* @__PURE__ */ jsx(
+    MuiAvatar,
+    {
+      src: imgSrc,
+      slotProps: {
+        ...slotProps ?? {},
+        img: {
+          referrerPolicy: "no-referrer",
+          ...slotProps?.img ?? {},
+          onError
+        }
+      },
+      ...props,
+      children
+    }
+  );
+});
+
+// src/components/DatePicker.tsx
+import React from "react";
+import { memo as memo2, useMemo, useCallback as useCallback2, useHistoryState } from "@lowentry/react-redux";
+import { IS_ARRAY, STRING as STRING2 } from "@lowentry/utils";
+import Dayjs from "dayjs";
+import Button from "@mui/material/Button";
+import Stack from "@mui/material/Stack";
+import TextField from "@mui/material/TextField";
+import { DatePicker as MuiDatePicker } from "@mui/x-date-pickers/DatePicker";
+import ArrowBackIosNewIcon from "@mui/icons-material/ArrowBackIosNew";
+import ArrowForwardIosIcon from "@mui/icons-material/ArrowForwardIos";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var isReactElement = (val) => {
+  return React.isValidElement(val);
+};
+var DatePickerTextField = memo2(({ dateFormat, value, className, ownerState, ...props }) => {
+  const onClick = useMemo(() => {
+    if (ownerState?.open) {
+      return void 0;
+    }
+    const inputProps2 = props.InputProps;
+    if (!inputProps2?.endAdornment) {
+      return null;
+    }
+    const endAdornment = inputProps2.endAdornment;
+    if (!isReactElement(endAdornment)) {
+      return null;
+    }
+    let propsLoop = endAdornment.props;
+    while (propsLoop && typeof propsLoop === "object") {
+      const recordLoop = propsLoop;
+      if ("onClick" in recordLoop && typeof recordLoop.onClick === "function") {
+        return recordLoop.onClick;
+      }
+      if ("children" in recordLoop && recordLoop.children) {
+        propsLoop = recordLoop.children;
+        continue;
+      }
+      if (IS_ARRAY(propsLoop)) {
+        let continueLoop = false;
+        for (const propsLoopItem of propsLoop) {
+          if (isReactElement(propsLoopItem)) {
+            const itemProps = propsLoopItem.props;
+            if (itemProps && typeof itemProps === "object") {
+              propsLoop = itemProps;
+              continueLoop = true;
+            }
+          }
+        }
+        if (continueLoop) {
+          continue;
+        }
+      }
+      if (isReactElement(propsLoop)) {
+        const nextProps = propsLoop.props;
+        if (nextProps && typeof nextProps === "object") {
+          propsLoop = nextProps;
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    return null;
+  }, [ownerState, props.InputProps]);
+  const onSelect = useCallback2((event) => {
+    const target = event.target;
+    if (target && target instanceof HTMLInputElement) {
+      target.selectionStart = target.selectionEnd;
+    }
+    event.preventDefault();
+  }, []);
+  const inputProps = props.InputProps ?? {};
+  const formattedValue = useMemo(() => {
+    if (value === null || value === void 0) {
+      return "";
+    }
+    return Dayjs(value).format(STRING2(dateFormat));
+  }, [value, dateFormat]);
+  return /* @__PURE__ */ jsx2(Button, { variant: "outlined", onClick: onClick ?? void 0, children: /* @__PURE__ */ jsx2(
+    TextField,
+    {
+      ...props,
+      className: "lowentry-mui--date-picker--textfield " + (STRING2(className) ?? ""),
+      variant: "outlined",
+      value: formattedValue,
+      InputProps: {
+        ...inputProps,
+        readOnly: true,
+        endAdornment: null,
+        onSelect,
+        onSelectCapture: onSelect,
+        onMouseDown: onSelect,
+        onTouchStart: onSelect,
+        onTouchMove: onSelect
+      }
+    }
+  ) });
+});
+var DatePicker = memo2(({ value, dateFormat, onChange, className, children, ...props }) => {
+  const textFieldProps = useMemo(() => {
+    if (!dateFormat) {
+      return { dateFormat: "ddd, D MMM YYYY" };
+    }
+    return { dateFormat };
+  }, [dateFormat]);
+  const [datepickerOpen, openDatepicker, closeDatepicker] = useHistoryState(false);
+  const onChanged = useCallback2(
+    (value2) => {
+      if (onChange) {
+        onChange(value2);
+      }
+    },
+    [onChange]
+  );
+  return /* @__PURE__ */ jsxs(
+    Stack,
+    {
+      className: "lowentry-mui--date-picker " + (className ?? ""),
+      direction: "row",
+      justifyContent: "space-between",
+      spacing: 1,
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx2(
+          Button,
+          {
+            className: "lowentry-mui--date-picker--arrow-button",
+            variant: "text",
+            color: "primary",
+            onClick: () => onChanged(Dayjs(value).subtract(1, "day")),
+            children: /* @__PURE__ */ jsx2(ArrowBackIosNewIcon, {})
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          MuiDatePicker,
+          {
+            open: datepickerOpen,
+            onOpen: openDatepicker,
+            onClose: closeDatepicker,
+            showDaysOutsideCurrentMonth: true,
+            views: ["day"],
+            format: "YYYY-MM-DD",
+            enableAccessibleFieldDOMStructure: false,
+            label: "",
+            value: value ? Dayjs(value) : null,
+            onChange: onChanged,
+            slots: {
+              textField: DatePickerTextField,
+              toolbar: () => null
+            },
+            slotProps: {
+              textField: {
+                dateFormat: textFieldProps.dateFormat
+              }
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          Button,
+          {
+            className: "lowentry-mui--date-picker--arrow-button",
+            variant: "text",
+            color: "primary",
+            onClick: () => onChanged(Dayjs(value).add(1, "day")),
+            children: /* @__PURE__ */ jsx2(ArrowForwardIosIcon, {})
+          }
+        ),
+        children
+      ]
+    }
+  );
+});
+
+// src/components/Dialog.tsx
+import { memo as memo3, useMemo as useMemo2, useCallback as useCallback3 } from "@lowentry/react-redux";
+import { LeUtils as LeUtils2, STRING as STRING3 } from "@lowentry/utils";
+import MuiDialog from "@mui/material/Dialog";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var Dialog = memo3(({ onClose, children, "aria-label": ariaLabel, open, ...props }) => {
+  const ariaLabelId = useMemo2(() => "lowentrymui_dialog_arialabel_" + LeUtils2.uniqueId(), []);
+  const onClosed = useCallback3(
+    (event, reason) => {
+      if (!STRING3(reason).toLowerCase().includes("escape")) {
+        return;
+      }
+      if (onClose) {
+        onClose(event, reason);
+      }
+    },
+    [onClose]
+  );
+  return /* @__PURE__ */ jsxs2(MuiDialog, { className: "lowentry-mui--dialog", onClose: onClosed, "aria-labelledby": ariaLabelId, open: open ?? false, ...props, children: [
+    /* @__PURE__ */ jsx3("span", { className: "lowentry-mui--dialog--arialabel", id: ariaLabelId, style: { display: "none" }, children: ariaLabel ?? "" }),
+    children
+  ] });
+});
+
+// src/components/InitiallyInvisible.tsx
+import { memo as memo4, useState, useEffect } from "@lowentry/react-redux";
+import { LeUtils as LeUtils3, INT_LAX as INT_LAX2 } from "@lowentry/utils";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var InitiallyInvisible = memo4(
+  ({ frames, transition, style, children, opacityKey, ...other }) => {
+    const [opacity, setOpacity] = useState(0);
+    useEffect(() => {
+      setOpacity(0);
+      return LeUtils3.setAnimationFrameTimeout(() => setOpacity(1), Math.max(opacityKey ? 2 : 0, INT_LAX2(frames))).remove;
+    }, [opacityKey, frames]);
+    return /* @__PURE__ */ jsx4(
+      "div",
+      {
+        style: {
+          width: "100%",
+          height: "100%",
+          opacity,
+          transition: opacity > 0 && transition ? "opacity " + transition : "none",
+          ...style ?? {}
+        },
+        ...other,
+        children
+      }
+    );
+  }
+);
+
+// src/components/LoadingSpinner/LoadingSpinner.tsx
+import { memo as memo5, useEffect as useEffect2, trigger, useTriggerable } from "@lowentry/react-redux";
+import Backdrop from "@mui/material/Backdrop";
+import CircularProgress from "@mui/material/CircularProgress";
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var loadingSpinnerCount = {};
+var LoadingSpinnerGrab = ({ type }) => {
+  loadingSpinnerCount[type] = (loadingSpinnerCount[type] || 0) + 1;
+  if (loadingSpinnerCount[type] === 1) {
+    trigger("lowentry-mui--loading-spinner--" + type, {});
+  }
+};
+var LoadingSpinnerRelease = ({ type }) => {
+  loadingSpinnerCount[type] = (loadingSpinnerCount[type] || 1) - 1;
+  if (loadingSpinnerCount[type] === 0) {
+    trigger("lowentry-mui--loading-spinner--" + type, {});
+  }
+};
+var LoadingSpinner = memo5(({ type }) => {
+  useEffect2(() => {
+    LoadingSpinnerGrab({ type });
+    return () => LoadingSpinnerRelease({ type });
+  }, [type]);
+  return null;
+});
+var LoadingSpinnerWidget = memo5(({ type, className, sx, children, ...props }) => {
+  useTriggerable("lowentry-mui--loading-spinner--" + type);
+  return /* @__PURE__ */ jsxs3(
+    Backdrop,
+    {
+      className: "lowentry-mui--loading-spinner lowentry-mui--loading-spinner--" + type + " " + (className ?? ""),
+      sx: { zIndex: (theme) => theme.zIndex.drawer + 1, ...sx ?? {} },
+      open: (loadingSpinnerCount[type] || 0) > 0,
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx5(CircularProgress, { color: "inherit", size: "min(120px,30vw)" }),
+        children
+      ]
+    }
+  );
+});
+
+// src/components/MenuButton.tsx
+import React2, { cloneElement } from "react";
+import { memo as memo6, useRef, useState as useState2, useCallback as useCallback4, mergeRefs } from "@lowentry/react-redux";
+import { LeUtils as LeUtils4, ARRAY } from "@lowentry/utils";
+import Button2 from "@mui/material/Button";
+import Menu from "@mui/material/Menu";
+import { Fragment, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var MenuButton = memo6(({ icon, className, ref, onClick, onClose, children, ...props }) => {
+  const buttonRef = useRef(null);
+  const [open, setOpen] = useState2(false);
+  const onClicked = useCallback4(
+    (event) => {
+      setOpen(true);
+      if (onClick) {
+        onClick(event);
+      }
+    },
+    [onClick]
+  );
+  const onClosed = useCallback4(
+    (event) => {
+      setOpen(false);
+      if (onClose) {
+        onClose(event);
+      }
+    },
+    [onClose]
+  );
+  return /* @__PURE__ */ jsxs4(Fragment, { children: [
+    /* @__PURE__ */ jsx6(
+      Button2,
+      {
+        ref: mergeRefs(buttonRef, ref ?? null),
+        className: "lowentry-mui--menu-button " + (className ?? ""),
+        variant: "text",
+        color: "primary",
+        onClick: onClicked,
+        ...props,
+        children: icon
+      }
+    ),
+    /* @__PURE__ */ jsx6(Menu, {
+      anchorEl: buttonRef.current,
+      open,
+      onClose: onClosed,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Dynamic children mapping
+      children: LeUtils4.mapToArray(ARRAY(children), (child, index) => {
+        if (!child || !React2.isValidElement(child)) {
+          return null;
+        }
+        const indexNum = typeof index === "number" ? index : 0;
+        const isRecordLike = (value) => typeof value === "object" && value !== null;
+        const childProps = isRecordLike(child.props) ? child.props : {};
+        const hasOnClick = "onClick" in childProps && typeof childProps.onClick === "function";
+        const hasDisabled = "disabled" in childProps && typeof childProps.disabled === "boolean";
+        const newProps = {
+          ...childProps,
+          key: indexNum,
+          onClick: () => {
+            setOpen(false);
+            if (hasOnClick && typeof childProps.onClick === "function") {
+              const clickHandler = childProps.onClick;
+              clickHandler();
+            }
+          },
+          disabled: hasDisabled ? !!childProps.disabled : !hasOnClick
+        };
+        return cloneElement(child, newProps);
+      })
+    })
+  ] });
+});
+
+// src/components/MuiRoot.tsx
+import { memo as memo7 } from "@lowentry/react-redux";
+import CssBaseline from "@mui/material/CssBaseline";
+import { ThemeProvider } from "@mui/material/styles";
+import { LocalizationProvider } from "@mui/x-date-pickers/LocalizationProvider";
+import { AdapterDayjs } from "@mui/x-date-pickers/AdapterDayjs";
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var MuiRoot = memo7(({ theme, className, children, ...props }) => {
+  return /* @__PURE__ */ jsxs5(Fragment2, { children: [
+    /* @__PURE__ */ jsx7(CssBaseline, {}),
+    /* @__PURE__ */ jsx7(ThemeProvider, { theme, children: /* @__PURE__ */ jsx7(LocalizationProvider, { dateAdapter: AdapterDayjs, children: /* @__PURE__ */ jsx7("div", { className: "lowentry-mui--mui-root " + (className ?? ""), ...props, children }) }) })
+  ] });
+});
+
+// src/components/NumericTextField.tsx
+import { memo as memo9, useCallback as useCallback6, useState as useState3, useEffect as useEffect3 } from "@lowentry/react-redux";
+import { FLOAT_LAX, INT_LAX_ANY, STRING as STRING4 } from "@lowentry/utils";
+
+// src/components/TextField.tsx
+import { memo as memo8, useCallback as useCallback5 } from "@lowentry/react-redux";
+import MuiTextField from "@mui/material/TextField";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var TextField2 = memo8(({ className, onClick, children, ...props }) => {
+  const onClicked = useCallback5(
+    (event) => {
+      try {
+        event.stopPropagation();
+      } catch {
+      }
+      if (onClick) {
+        onClick(event);
+      }
+    },
+    [onClick]
+  );
+  return /* @__PURE__ */ jsx8(
+    MuiTextField,
+    {
+      className: "lowentry-mui--textfield " + (className ?? ""),
+      autoComplete: "off",
+      onClick: onClicked,
+      ...props,
+      children
+    }
+  );
+});
+var TextField_default = TextField2;
+
+// src/components/NumericTextField.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var getProcessedValue = (value, decimals, allowZero, allowNegative) => {
+  let text = LeMuiUtils.purgePrependedHiddenChar(STRING4(value));
+  let val = 0;
+  const negative = text.includes("-");
+  text = text.replace(",", ".").replace(/[^0-9.]/g, "");
+  if (text !== "") {
+    let stringVal = Math.abs(FLOAT_LAX(text)).toFixed(decimals + 1);
+    stringVal = stringVal.substring(0, stringVal.length - 1);
+    const textDotCount = text.split(".").length - 1;
+    if (textDotCount <= 0 || decimals <= 0) {
+      text = stringVal.split(".")[0];
+    } else if (textDotCount === 1 && text.endsWith(".")) {
+      text = stringVal.split(".")[0] + ".";
+    } else {
+      text = stringVal.substring(0, stringVal.length - Math.max(0, decimals - text.split(".")[1].length));
+    }
+    if (!allowZero && text === "0") {
+      text = "";
+    }
+  }
+  if (allowNegative && negative) {
+    text = "-" + text;
+  }
+  val = FLOAT_LAX(text);
+  if (val !== 0) {
+    if (decimals > 0) {
+      val = Math.round(val * Math.pow(10, decimals)) / Math.pow(10, decimals);
+    } else {
+      val = Math.round(val);
+    }
+  }
+  return { text, val };
+};
+var NumericTextField = memo9(
+  ({
+    decimals: decimalsProp,
+    allowZero: allowZeroProp,
+    allowNegative: allowNegativeProp,
+    value,
+    onChange,
+    onRenderValue,
+    className,
+    inputProps,
+    children,
+    ...props
+  }) => {
+    const allowZero = !!allowZeroProp;
+    const allowNegative = !!allowNegativeProp;
+    const decimals = INT_LAX_ANY(decimalsProp, 0);
+    const getVisualValue = useCallback6(
+      (val) => {
+        return getProcessedValue(val, decimals, allowZero, allowNegative).text;
+      },
+      [decimals, allowZero, allowNegative]
+    );
+    const [visualValue, setVisualValue] = useState3(getVisualValue(value));
+    useEffect3(() => {
+      const newVisualValue = getVisualValue(value);
+      if (FLOAT_LAX(visualValue) !== FLOAT_LAX(newVisualValue)) {
+        setVisualValue(newVisualValue);
+      }
+    }, [value, getVisualValue]);
+    const onChanged = useCallback6(
+      (event) => {
+        const originalTargetValue = event.target.value;
+        const { text, val } = getProcessedValue(originalTargetValue, decimals, allowZero, allowNegative);
+        setVisualValue(text);
+        if (onChange) {
+          const newTarget = {
+            ...event.target,
+            value: val,
+            valueText: text,
+            valueRaw: originalTargetValue
+          };
+          const newEvent = {
+            ...event,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Custom event target augmentation
+            target: newTarget
+          };
+          onChange(newEvent);
+        }
+      },
+      [onChange, decimals, allowZero, allowNegative]
+    );
+    return /* @__PURE__ */ jsx9(
+      TextField_default,
+      {
+        className: "lowentry-mui--numeric-textfield " + (className ?? ""),
+        type: "text",
+        inputProps: { inputMode: "decimal", ...inputProps ?? {} },
+        value: onRenderValue ? onRenderValue(visualValue) : visualValue,
+        onChange: onChanged,
+        ...props,
+        children
+      }
+    );
+  }
+);
+var NumericTextField_default = NumericTextField;
+
+// src/components/RemovableNumericTextField.tsx
+import { memo as memo10, useCallback as useCallback7 } from "@lowentry/react-redux";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var RemovableNumericTextField = memo10(
+  ({ onRemove, onChange, onSelect, className, children, ...props }) => {
+    const onChanged = useCallback7(
+      (event) => {
+        if (event.target.valueRaw === "") {
+          if (onRemove) {
+            onRemove(event);
+          }
+          return;
+        }
+        if (onChange) {
+          onChange(event);
+        }
+      },
+      [onRemove, onChange]
+    );
+    const onSelected = useCallback7(
+      (event) => {
+        LeMuiUtils.onSelectEnsureMinimumOffset(1)(event);
+        if (onSelect) {
+          onSelect(event);
+        }
+      },
+      [onSelect]
+    );
+    const onSelectedWrapper = useCallback7(
+      (event) => {
+        const target = event.target;
+        if (target && (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement)) {
+          Function.prototype.call.call(onSelected, void 0, {
+            ...event,
+            target,
+            currentTarget: target
+          });
+        }
+      },
+      [onSelected]
+    );
+    return /* @__PURE__ */ jsx10(
+      NumericTextField_default,
+      {
+        className: "lowentry-mui--removable-textfield lowentry-mui--removable-numeric-textfield " + (className ?? ""),
+        onRenderValue: LeMuiUtils.prependHiddenChar,
+        onChange: onChanged,
+        onSelect: onSelectedWrapper,
+        ...props,
+        children
+      }
+    );
+  }
+);
+
+// src/components/RemovableTextField.tsx
+import { memo as memo11, useCallback as useCallback8 } from "@lowentry/react-redux";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var RemovableTextField = memo11(
+  ({ className, value, onRemove, onChange, onSelect, children, ...props }) => {
+    const onChanged = useCallback8(
+      (event) => {
+        if (event.target.value === "") {
+          if (onRemove) {
+            onRemove(event);
+          }
+          return;
+        }
+        if (onChange) {
+          const newEvent = {
+            ...event,
+            target: {
+              ...event.target,
+              value: LeMuiUtils.purgePrependedHiddenChar(event.target.value)
+            }
+          };
+          onChange(newEvent);
+        }
+      },
+      [onRemove, onChange]
+    );
+    const onSelected = useCallback8(
+      (event) => {
+        LeMuiUtils.onSelectEnsureMinimumOffset(1)(event);
+        if (onSelect) {
+          onSelect(event);
+        }
+      },
+      [onSelect]
+    );
+    const onSelectedWrapper = useCallback8(
+      (event) => {
+        const target = event.target;
+        if (target && (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement)) {
+          Function.prototype.call.call(onSelected, void 0, {
+            ...event,
+            target,
+            currentTarget: target
+          });
+        }
+      },
+      [onSelected]
+    );
+    return /* @__PURE__ */ jsx11(
+      TextField_default,
+      {
+        className: "lowentry-mui--removable-textfield " + (className ?? ""),
+        value: LeMuiUtils.prependHiddenChar(String(value ?? "")),
+        onChange: onChanged,
+        onSelect: onSelectedWrapper,
+        ...props,
+        children
+      }
+    );
+  }
+);
+
+// src/components/Submittable.tsx
+import { memo as memo12, useCallback as useCallback9 } from "@lowentry/react-redux";
+import Stack2 from "@mui/material/Stack";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var Submittable = memo12(({ onSubmit, disabled, sx, children, ...props }) => {
+  const handleSubmit = useCallback9(
+    (event) => {
+      try {
+        event.preventDefault();
+      } catch {
+      }
+      if (disabled) {
+        if (!(typeof disabled === "function") || disabled()) {
+          return;
+        }
+      }
+      if (onSubmit) {
+        onSubmit(event);
+      }
+    },
+    [onSubmit, disabled]
+  );
+  return /* @__PURE__ */ jsx12("form", { style: sx, onSubmit: handleSubmit, children: /* @__PURE__ */ jsx12(Stack2, { ...props, children }) });
+});
+export {
+  Avatar,
+  DatePicker,
+  Dialog,
+  InitiallyInvisible,
+  LeMuiUtils,
+  LoadingSpinner,
+  LoadingSpinnerWidget,
+  MenuButton,
+  MuiRoot,
+  NumericTextField,
+  RemovableNumericTextField,
+  RemovableTextField,
+  Submittable,
+  TextField2 as TextField
+};
+//# sourceMappingURL=index.js.map