everest-npm-features 0.0.1

package/dist/hooks/useSnackBar.js

@@ -0,0 +1,968 @@
+import { jsx as a, jsxs as ne } from "react/jsx-runtime";
+import * as b from "react";
+import { useState as R, useCallback as j } from "react";
+import { g as F, e as T, k as X, l as K, P as e, m as be } from "../createTheme-NrBCWesw.js";
+import { c as W, u as Ce } from "../useTimeout-lr7ryrda.js";
+import { P as re, u as Z, e as Y } from "../useSlot-CURNJ3JC.js";
+import { u as Se } from "../useTheme-nlj1B_-c.js";
+import { g as U, s as O, m as V, d as $, u as _, a as se, b as q } from "../createSimplePaletteValueFilter-CsgjlRAs.js";
+import { u as ke, G as we } from "../Grow-B3Swdn2Z.js";
+import { u as Ee } from "../TransitionGroupContext-VwpFXTPO.js";
+import { g as Oe, c as H, e as Te } from "../utils-_FXWkn40.js";
+import { e as Re } from "../exactProp-C1Lmtwf_.js";
+import { c as M } from "../createSvgIcon-CAZr4ukt.js";
+import { I as Me } from "../IconButton-CRGy76pJ.js";
+import { S as z } from "../Slide-BlS6unRJ.js";
+function Ae(o) {
+  return F("MuiAlert", o);
+}
+const J = U("MuiAlert", ["root", "action", "icon", "message", "filled", "colorSuccess", "colorInfo", "colorWarning", "colorError", "filledSuccess", "filledInfo", "filledWarning", "filledError", "outlined", "outlinedSuccess", "outlinedInfo", "outlinedWarning", "outlinedError", "standard", "standardSuccess", "standardInfo", "standardWarning", "standardError"]), xe = M(/* @__PURE__ */ a("path", {
+  d: "M20,12A8,8 0 0,1 12,20A8,8 0 0,1 4,12A8,8 0 0,1 12,4C12.76,4 13.5,4.11 14.2, 4.31L15.77,2.74C14.61,2.26 13.34,2 12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0, 0 22,12M7.91,10.08L6.5,11.5L11,16L21,6L19.59,4.58L11,13.17L7.91,10.08Z"
+}), "SuccessOutlined"), Le = M(/* @__PURE__ */ a("path", {
+  d: "M12 5.99L19.53 19H4.47L12 5.99M12 2L1 21h22L12 2zm1 14h-2v2h2v-2zm0-6h-2v4h2v-4z"
+}), "ReportProblemOutlined"), Pe = M(/* @__PURE__ */ a("path", {
+  d: "M11 15h2v2h-2zm0-8h2v6h-2zm.99-5C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"
+}), "ErrorOutline"), Ie = M(/* @__PURE__ */ a("path", {
+  d: "M11,9H13V7H11M12,20C7.59,20 4,16.41 4,12C4,7.59 7.59,4 12,4C16.41,4 20,7.59 20, 12C20,16.41 16.41,20 12,20M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10, 10 0 0,0 12,2M11,17H13V11H11V17Z"
+}), "InfoOutlined"), ze = M(/* @__PURE__ */ a("path", {
+  d: "M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"
+}), "Close"), De = (o) => {
+  const {
+    variant: t,
+    color: r,
+    severity: n,
+    classes: u
+  } = o, p = {
+    root: ["root", `color${T(r || n)}`, `${t}${T(r || n)}`, `${t}`],
+    icon: ["icon"],
+    message: ["message"],
+    action: ["action"]
+  };
+  return q(p, Ae, u);
+}, Ne = O(re, {
+  name: "MuiAlert",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.root, t[r.variant], t[`${r.variant}${T(r.color || r.severity)}`]];
+  }
+})(V(({
+  theme: o
+}) => {
+  const t = o.palette.mode === "light" ? X : K, r = o.palette.mode === "light" ? K : X;
+  return {
+    ...o.typography.body2,
+    backgroundColor: "transparent",
+    display: "flex",
+    padding: "6px 16px",
+    variants: [...Object.entries(o.palette).filter($(["light"])).map(([n]) => ({
+      props: {
+        colorSeverity: n,
+        variant: "standard"
+      },
+      style: {
+        color: o.vars ? o.vars.palette.Alert[`${n}Color`] : t(o.palette[n].light, 0.6),
+        backgroundColor: o.vars ? o.vars.palette.Alert[`${n}StandardBg`] : r(o.palette[n].light, 0.9),
+        [`& .${J.icon}`]: o.vars ? {
+          color: o.vars.palette.Alert[`${n}IconColor`]
+        } : {
+          color: o.palette[n].main
+        }
+      }
+    })), ...Object.entries(o.palette).filter($(["light"])).map(([n]) => ({
+      props: {
+        colorSeverity: n,
+        variant: "outlined"
+      },
+      style: {
+        color: o.vars ? o.vars.palette.Alert[`${n}Color`] : t(o.palette[n].light, 0.6),
+        border: `1px solid ${(o.vars || o).palette[n].light}`,
+        [`& .${J.icon}`]: o.vars ? {
+          color: o.vars.palette.Alert[`${n}IconColor`]
+        } : {
+          color: o.palette[n].main
+        }
+      }
+    })), ...Object.entries(o.palette).filter($(["dark"])).map(([n]) => ({
+      props: {
+        colorSeverity: n,
+        variant: "filled"
+      },
+      style: {
+        fontWeight: o.typography.fontWeightMedium,
+        ...o.vars ? {
+          color: o.vars.palette.Alert[`${n}FilledColor`],
+          backgroundColor: o.vars.palette.Alert[`${n}FilledBg`]
+        } : {
+          backgroundColor: o.palette.mode === "dark" ? o.palette[n].dark : o.palette[n].main,
+          color: o.palette.getContrastText(o.palette[n].main)
+        }
+      }
+    }))]
+  };
+})), Be = O("div", {
+  name: "MuiAlert",
+  slot: "Icon",
+  overridesResolver: (o, t) => t.icon
+})({
+  marginRight: 12,
+  padding: "7px 0",
+  display: "flex",
+  fontSize: 22,
+  opacity: 0.9
+}), je = O("div", {
+  name: "MuiAlert",
+  slot: "Message",
+  overridesResolver: (o, t) => t.message
+})({
+  padding: "8px 0",
+  minWidth: 0,
+  overflow: "auto"
+}), Q = O("div", {
+  name: "MuiAlert",
+  slot: "Action",
+  overridesResolver: (o, t) => t.action
+})({
+  display: "flex",
+  alignItems: "flex-start",
+  padding: "4px 0 0 16px",
+  marginLeft: "auto",
+  marginRight: -8
+}), ee = {
+  success: /* @__PURE__ */ a(xe, {
+    fontSize: "inherit"
+  }),
+  warning: /* @__PURE__ */ a(Le, {
+    fontSize: "inherit"
+  }),
+  error: /* @__PURE__ */ a(Pe, {
+    fontSize: "inherit"
+  }),
+  info: /* @__PURE__ */ a(Ie, {
+    fontSize: "inherit"
+  })
+}, ae = /* @__PURE__ */ b.forwardRef(function(t, r) {
+  const n = _({
+    props: t,
+    name: "MuiAlert"
+  }), {
+    action: u,
+    children: p,
+    className: C,
+    closeText: f = "Close",
+    color: h,
+    components: y = {},
+    componentsProps: g = {},
+    icon: m,
+    iconMapping: k = ee,
+    onClose: S,
+    role: l = "alert",
+    severity: i = "success",
+    slotProps: v = {},
+    slots: s = {},
+    variant: c = "standard",
+    ...d
+  } = n, w = {
+    ...n,
+    color: h,
+    severity: i,
+    variant: c,
+    colorSeverity: h || i
+  }, E = De(w), D = {
+    slots: {
+      closeButton: y.CloseButton,
+      closeIcon: y.CloseIcon,
+      ...s
+    },
+    slotProps: {
+      ...g,
+      ...v
+    }
+  }, [A, x] = Z("closeButton", {
+    elementType: Me,
+    externalForwardedProps: D,
+    ownerState: w
+  }), [L, P] = Z("closeIcon", {
+    elementType: ze,
+    externalForwardedProps: D,
+    ownerState: w
+  });
+  return /* @__PURE__ */ ne(Ne, {
+    role: l,
+    elevation: 0,
+    ownerState: w,
+    className: se(E.root, C),
+    ref: r,
+    ...d,
+    children: [m !== !1 ? /* @__PURE__ */ a(Be, {
+      ownerState: w,
+      className: E.icon,
+      children: m || k[i] || ee[i]
+    }) : null, /* @__PURE__ */ a(je, {
+      ownerState: w,
+      className: E.message,
+      children: p
+    }), u != null ? /* @__PURE__ */ a(Q, {
+      ownerState: w,
+      className: E.action,
+      children: u
+    }) : null, u == null && S ? /* @__PURE__ */ a(Q, {
+      ownerState: w,
+      className: E.action,
+      children: /* @__PURE__ */ a(A, {
+        size: "small",
+        "aria-label": f,
+        title: f,
+        color: "inherit",
+        onClick: S,
+        ...x,
+        children: /* @__PURE__ */ a(L, {
+          fontSize: "small",
+          ...P
+        })
+      })
+    }) : null]
+  });
+});
+process.env.NODE_ENV !== "production" && (ae.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The action to display. It renders after the message, at the end of the alert.
+   */
+  action: e.node,
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * Override the default label for the *close popup* icon button.
+   *
+   * For localization purposes, you can use the provided [translations](https://mui.com/material-ui/guides/localization/).
+   * @default 'Close'
+   */
+  closeText: e.string,
+  /**
+   * The color of the component. Unless provided, the value is taken from the `severity` prop.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   */
+  color: e.oneOfType([e.oneOf(["error", "info", "success", "warning"]), e.string]),
+  /**
+   * The components used for each slot inside.
+   *
+   * @deprecated use the `slots` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  components: e.shape({
+    CloseButton: e.elementType,
+    CloseIcon: e.elementType
+  }),
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  componentsProps: e.shape({
+    closeButton: e.object,
+    closeIcon: e.object
+  }),
+  /**
+   * Override the icon displayed before the children.
+   * Unless provided, the icon is mapped to the value of the `severity` prop.
+   * Set to `false` to remove the `icon`.
+   */
+  icon: e.node,
+  /**
+   * The component maps the `severity` prop to a range of different icons,
+   * for instance success to `<SuccessOutlined>`.
+   * If you wish to change this mapping, you can provide your own.
+   * Alternatively, you can use the `icon` prop to override the icon displayed.
+   */
+  iconMapping: e.shape({
+    error: e.node,
+    info: e.node,
+    success: e.node,
+    warning: e.node
+  }),
+  /**
+   * Callback fired when the component requests to be closed.
+   * When provided and no `action` prop is set, a close icon button is displayed that triggers the callback when clicked.
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   */
+  onClose: e.func,
+  /**
+   * The ARIA role attribute of the element.
+   * @default 'alert'
+   */
+  role: e.string,
+  /**
+   * The severity of the alert. This defines the color and icon used.
+   * @default 'success'
+   */
+  severity: e.oneOfType([e.oneOf(["error", "info", "success", "warning"]), e.string]),
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: e.shape({
+    closeButton: e.oneOfType([e.func, e.object]),
+    closeIcon: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: e.shape({
+    closeButton: e.elementType,
+    closeIcon: e.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The variant to use.
+   * @default 'standard'
+   */
+  variant: e.oneOfType([e.oneOf(["filled", "outlined", "standard"]), e.string])
+});
+function oe(o) {
+  return o.substring(2).toLowerCase();
+}
+function $e(o, t) {
+  return t.documentElement.clientWidth < o.clientX || t.documentElement.clientHeight < o.clientY;
+}
+function I(o) {
+  const {
+    children: t,
+    disableReactTree: r = !1,
+    mouseEvent: n = "onClick",
+    onClickAway: u,
+    touchEvent: p = "onTouchEnd"
+  } = o, C = b.useRef(!1), f = b.useRef(null), h = b.useRef(!1), y = b.useRef(!1);
+  b.useEffect(() => (setTimeout(() => {
+    h.current = !0;
+  }, 0), () => {
+    h.current = !1;
+  }), []);
+  const g = Ee(Oe(t), f), m = W((l) => {
+    const i = y.current;
+    y.current = !1;
+    const v = H(f.current);
+    if (!h.current || !f.current || "clientX" in l && $e(l, v))
+      return;
+    if (C.current) {
+      C.current = !1;
+      return;
+    }
+    let s;
+    l.composedPath ? s = l.composedPath().includes(f.current) : s = !v.documentElement.contains(
+      // @ts-expect-error returns `false` as intended when not dispatched from a Node
+      l.target
+    ) || f.current.contains(
+      // @ts-expect-error returns `false` as intended when not dispatched from a Node
+      l.target
+    ), !s && (r || !i) && u(l);
+  }), k = (l) => (i) => {
+    y.current = !0;
+    const v = t.props[l];
+    v && v(i);
+  }, S = {
+    ref: g
+  };
+  return p !== !1 && (S[p] = k(p)), b.useEffect(() => {
+    if (p !== !1) {
+      const l = oe(p), i = H(f.current), v = () => {
+        C.current = !0;
+      };
+      return i.addEventListener(l, m), i.addEventListener("touchmove", v), () => {
+        i.removeEventListener(l, m), i.removeEventListener("touchmove", v);
+      };
+    }
+  }, [m, p]), n !== !1 && (S[n] = k(n)), b.useEffect(() => {
+    if (n !== !1) {
+      const l = oe(n), i = H(f.current);
+      return i.addEventListener(l, m), () => {
+        i.removeEventListener(l, m);
+      };
+    }
+  }, [m, n]), /* @__PURE__ */ a(b.Fragment, {
+    children: /* @__PURE__ */ b.cloneElement(t, S)
+  });
+}
+process.env.NODE_ENV !== "production" && (I.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The wrapped element.
+   */
+  children: Te.isRequired,
+  /**
+   * If `true`, the React tree is ignored and only the DOM tree is considered.
+   * This prop changes how portaled elements are handled.
+   * @default false
+   */
+  disableReactTree: e.bool,
+  /**
+   * The mouse event to listen to. You can disable the listener by providing `false`.
+   * @default 'onClick'
+   */
+  mouseEvent: e.oneOf(["onClick", "onMouseDown", "onMouseUp", "onPointerDown", "onPointerUp", !1]),
+  /**
+   * Callback fired when a "click away" event is detected.
+   */
+  onClickAway: e.func.isRequired,
+  /**
+   * The touch event to listen to. You can disable the listener by providing `false`.
+   * @default 'onTouchEnd'
+   */
+  touchEvent: e.oneOf(["onTouchEnd", "onTouchStart", !1])
+});
+process.env.NODE_ENV !== "production" && (I.propTypes = Re(I.propTypes));
+function He(o = {}) {
+  const {
+    autoHideDuration: t = null,
+    disableWindowBlurListener: r = !1,
+    onClose: n,
+    open: u,
+    resumeHideDuration: p
+  } = o, C = Ce();
+  b.useEffect(() => {
+    if (!u)
+      return;
+    function s(c) {
+      c.defaultPrevented || c.key === "Escape" && (n == null || n(c, "escapeKeyDown"));
+    }
+    return document.addEventListener("keydown", s), () => {
+      document.removeEventListener("keydown", s);
+    };
+  }, [u, n]);
+  const f = W((s, c) => {
+    n == null || n(s, c);
+  }), h = W((s) => {
+    !n || s == null || C.start(s, () => {
+      f(null, "timeout");
+    });
+  });
+  b.useEffect(() => (u && h(t), C.clear), [u, t, h, C]);
+  const y = (s) => {
+    n == null || n(s, "clickaway");
+  }, g = C.clear, m = b.useCallback(() => {
+    t != null && h(p ?? t * 0.5);
+  }, [t, p, h]), k = (s) => (c) => {
+    const d = s.onBlur;
+    d == null || d(c), m();
+  }, S = (s) => (c) => {
+    const d = s.onFocus;
+    d == null || d(c), g();
+  }, l = (s) => (c) => {
+    const d = s.onMouseEnter;
+    d == null || d(c), g();
+  }, i = (s) => (c) => {
+    const d = s.onMouseLeave;
+    d == null || d(c), m();
+  };
+  return b.useEffect(() => {
+    if (!r && u)
+      return window.addEventListener("focus", m), window.addEventListener("blur", g), () => {
+        window.removeEventListener("focus", m), window.removeEventListener("blur", g);
+      };
+  }, [r, u, m, g]), {
+    getRootProps: (s = {}) => {
+      const c = {
+        ...Y(o),
+        ...Y(s)
+      };
+      return {
+        // ClickAwayListener adds an `onClick` prop which results in the alert not being announced.
+        // See https://github.com/mui/material-ui/issues/29080
+        role: "presentation",
+        ...s,
+        ...c,
+        onBlur: k(c),
+        onFocus: S(c),
+        onMouseEnter: l(c),
+        onMouseLeave: i(c)
+      };
+    },
+    onClickAway: y
+  };
+}
+function We(o) {
+  return F("MuiSnackbarContent", o);
+}
+U("MuiSnackbarContent", ["root", "message", "action"]);
+const Fe = (o) => {
+  const {
+    classes: t
+  } = o;
+  return q({
+    root: ["root"],
+    action: ["action"],
+    message: ["message"]
+  }, We, t);
+}, Ue = O(re, {
+  name: "MuiSnackbarContent",
+  slot: "Root",
+  overridesResolver: (o, t) => t.root
+})(V(({
+  theme: o
+}) => {
+  const t = o.palette.mode === "light" ? 0.8 : 0.98, r = be(o.palette.background.default, t);
+  return {
+    ...o.typography.body2,
+    color: o.vars ? o.vars.palette.SnackbarContent.color : o.palette.getContrastText(r),
+    backgroundColor: o.vars ? o.vars.palette.SnackbarContent.bg : r,
+    display: "flex",
+    alignItems: "center",
+    flexWrap: "wrap",
+    padding: "6px 16px",
+    borderRadius: (o.vars || o).shape.borderRadius,
+    flexGrow: 1,
+    [o.breakpoints.up("sm")]: {
+      flexGrow: "initial",
+      minWidth: 288
+    }
+  };
+})), Ve = O("div", {
+  name: "MuiSnackbarContent",
+  slot: "Message",
+  overridesResolver: (o, t) => t.message
+})({
+  padding: "8px 0"
+}), _e = O("div", {
+  name: "MuiSnackbarContent",
+  slot: "Action",
+  overridesResolver: (o, t) => t.action
+})({
+  display: "flex",
+  alignItems: "center",
+  marginLeft: "auto",
+  paddingLeft: 16,
+  marginRight: -8
+}), ie = /* @__PURE__ */ b.forwardRef(function(t, r) {
+  const n = _({
+    props: t,
+    name: "MuiSnackbarContent"
+  }), {
+    action: u,
+    className: p,
+    message: C,
+    role: f = "alert",
+    ...h
+  } = n, y = n, g = Fe(y);
+  return /* @__PURE__ */ ne(Ue, {
+    role: f,
+    square: !0,
+    elevation: 6,
+    className: se(g.root, p),
+    ownerState: y,
+    ref: r,
+    ...h,
+    children: [/* @__PURE__ */ a(Ve, {
+      className: g.message,
+      ownerState: y,
+      children: C
+    }), u ? /* @__PURE__ */ a(_e, {
+      className: g.action,
+      ownerState: y,
+      children: u
+    }) : null]
+  });
+});
+process.env.NODE_ENV !== "production" && (ie.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The action to display. It renders after the message, at the end of the snackbar.
+   */
+  action: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The message to display.
+   */
+  message: e.node,
+  /**
+   * The ARIA role attribute of the element.
+   * @default 'alert'
+   */
+  role: e.string,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+function qe(o) {
+  return F("MuiSnackbar", o);
+}
+U("MuiSnackbar", ["root", "anchorOriginTopCenter", "anchorOriginBottomCenter", "anchorOriginTopRight", "anchorOriginBottomRight", "anchorOriginTopLeft", "anchorOriginBottomLeft"]);
+const Ge = (o) => {
+  const {
+    classes: t,
+    anchorOrigin: r
+  } = o, n = {
+    root: ["root", `anchorOrigin${T(r.vertical)}${T(r.horizontal)}`]
+  };
+  return q(n, qe, t);
+}, te = O("div", {
+  name: "MuiSnackbar",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.root, t[`anchorOrigin${T(r.anchorOrigin.vertical)}${T(r.anchorOrigin.horizontal)}`]];
+  }
+})(V(({
+  theme: o
+}) => ({
+  zIndex: (o.vars || o).zIndex.snackbar,
+  position: "fixed",
+  display: "flex",
+  left: 8,
+  right: 8,
+  justifyContent: "center",
+  alignItems: "center",
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => t.anchorOrigin.vertical === "top",
+    style: {
+      top: 8,
+      [o.breakpoints.up("sm")]: {
+        top: 24
+      }
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.anchorOrigin.vertical !== "top",
+    style: {
+      bottom: 8,
+      [o.breakpoints.up("sm")]: {
+        bottom: 24
+      }
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.anchorOrigin.horizontal === "left",
+    style: {
+      justifyContent: "flex-start",
+      [o.breakpoints.up("sm")]: {
+        left: 24,
+        right: "auto"
+      }
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.anchorOrigin.horizontal === "right",
+    style: {
+      justifyContent: "flex-end",
+      [o.breakpoints.up("sm")]: {
+        right: 24,
+        left: "auto"
+      }
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.anchorOrigin.horizontal === "center",
+    style: {
+      [o.breakpoints.up("sm")]: {
+        left: "50%",
+        right: "auto",
+        transform: "translateX(-50%)"
+      }
+    }
+  }]
+}))), ce = /* @__PURE__ */ b.forwardRef(function(t, r) {
+  const n = _({
+    props: t,
+    name: "MuiSnackbar"
+  }), u = Se(), p = {
+    enter: u.transitions.duration.enteringScreen,
+    exit: u.transitions.duration.leavingScreen
+  }, {
+    action: C,
+    anchorOrigin: {
+      vertical: f,
+      horizontal: h
+    } = {
+      vertical: "bottom",
+      horizontal: "left"
+    },
+    autoHideDuration: y = null,
+    children: g,
+    className: m,
+    ClickAwayListenerProps: k,
+    ContentProps: S,
+    disableWindowBlurListener: l = !1,
+    message: i,
+    onBlur: v,
+    onClose: s,
+    onFocus: c,
+    onMouseEnter: d,
+    onMouseLeave: w,
+    open: E,
+    resumeHideDuration: D,
+    TransitionComponent: A = we,
+    transitionDuration: x = p,
+    TransitionProps: {
+      onEnter: L,
+      onExited: P,
+      ...le
+    } = {},
+    ...ue
+  } = n, N = {
+    ...n,
+    anchorOrigin: {
+      vertical: f,
+      horizontal: h
+    },
+    autoHideDuration: y,
+    disableWindowBlurListener: l,
+    TransitionComponent: A,
+    transitionDuration: x
+  }, pe = Ge(N), {
+    getRootProps: de,
+    onClickAway: fe
+  } = He({
+    ...N
+  }), [ge, G] = b.useState(!0), me = ke({
+    elementType: te,
+    getSlotProps: de,
+    externalForwardedProps: ue,
+    ownerState: N,
+    additionalProps: {
+      ref: r
+    },
+    className: [pe.root, m]
+  }), ve = (B) => {
+    G(!0), P && P(B);
+  }, he = (B, ye) => {
+    G(!1), L && L(B, ye);
+  };
+  return !E && ge ? null : /* @__PURE__ */ a(I, {
+    onClickAway: fe,
+    ...k,
+    children: /* @__PURE__ */ a(te, {
+      ...me,
+      children: /* @__PURE__ */ a(A, {
+        appear: !0,
+        in: E,
+        timeout: x,
+        direction: f === "top" ? "down" : "up",
+        onEnter: he,
+        onExited: ve,
+        ...le,
+        children: g || /* @__PURE__ */ a(ie, {
+          message: i,
+          action: C,
+          ...S
+        })
+      })
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (ce.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The action to display. It renders after the message, at the end of the snackbar.
+   */
+  action: e.node,
+  /**
+   * The anchor of the `Snackbar`.
+   * On smaller screens, the component grows to occupy all the available width,
+   * the horizontal alignment is ignored.
+   * @default { vertical: 'bottom', horizontal: 'left' }
+   */
+  anchorOrigin: e.shape({
+    horizontal: e.oneOf(["center", "left", "right"]).isRequired,
+    vertical: e.oneOf(["bottom", "top"]).isRequired
+  }),
+  /**
+   * The number of milliseconds to wait before automatically calling the
+   * `onClose` function. `onClose` should then set the state of the `open`
+   * prop to hide the Snackbar. This behavior is disabled by default with
+   * the `null` value.
+   * @default null
+   */
+  autoHideDuration: e.number,
+  /**
+   * Replace the `SnackbarContent` component.
+   */
+  children: e.element,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * Props applied to the `ClickAwayListener` element.
+   */
+  ClickAwayListenerProps: e.object,
+  /**
+   * Props applied to the [`SnackbarContent`](https://mui.com/material-ui/api/snackbar-content/) element.
+   */
+  ContentProps: e.object,
+  /**
+   * If `true`, the `autoHideDuration` timer will expire even if the window is not focused.
+   * @default false
+   */
+  disableWindowBlurListener: e.bool,
+  /**
+   * When displaying multiple consecutive snackbars using a single parent-rendered
+   * `<Snackbar/>`, add the `key` prop to ensure independent treatment of each message.
+   * For instance, use `<Snackbar key={message} />`. Otherwise, messages might update
+   * in place, and features like `autoHideDuration` could be affected.
+   */
+  key: () => null,
+  /**
+   * The message to display.
+   */
+  message: e.node,
+  /**
+   * @ignore
+   */
+  onBlur: e.func,
+  /**
+   * Callback fired when the component requests to be closed.
+   * Typically `onClose` is used to set state in the parent component,
+   * which is used to control the `Snackbar` `open` prop.
+   * The `reason` parameter can optionally be used to control the response to `onClose`,
+   * for example ignoring `clickaway`.
+   *
+   * @param {React.SyntheticEvent<any> | Event} event The event source of the callback.
+   * @param {string} reason Can be: `"timeout"` (`autoHideDuration` expired), `"clickaway"`, or `"escapeKeyDown"`.
+   */
+  onClose: e.func,
+  /**
+   * @ignore
+   */
+  onFocus: e.func,
+  /**
+   * @ignore
+   */
+  onMouseEnter: e.func,
+  /**
+   * @ignore
+   */
+  onMouseLeave: e.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: e.bool,
+  /**
+   * The number of milliseconds to wait before dismissing after user interaction.
+   * If `autoHideDuration` prop isn't specified, it does nothing.
+   * If `autoHideDuration` prop is specified but `resumeHideDuration` isn't,
+   * we default to `autoHideDuration / 2` ms.
+   */
+  resumeHideDuration: e.number,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The component used for the transition.
+   * [Follow this guide](https://mui.com/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @default Grow
+   */
+  TransitionComponent: e.elementType,
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   * @default {
+   *   enter: theme.transitions.duration.enteringScreen,
+   *   exit: theme.transitions.duration.leavingScreen,
+   * }
+   */
+  transitionDuration: e.oneOfType([e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })]),
+  /**
+   * Props applied to the transition element.
+   * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
+   * @default {}
+   */
+  TransitionProps: e.object
+});
+const Xe = (o) => /* @__PURE__ */ a(z, { ...o, direction: "left" }), Ke = (o) => /* @__PURE__ */ a(z, { ...o, direction: "right" }), Ze = (o) => /* @__PURE__ */ a(z, { ...o, direction: "up" }), Ye = (o) => /* @__PURE__ */ a(z, { ...o, direction: "down" }), fo = () => {
+  const [o, t] = R(!1), [r, n] = R(""), [u, p] = R(2e3), [C, f] = R("error"), [h, y] = R({ vertical: "top", horizontal: "right" }), [g, m] = R("left"), k = j(
+    ({
+      message: i,
+      type: v = "error",
+      duration: s = 3e3,
+      animationDirection: c = "left",
+      position: d = { vertical: "top", horizontal: "right" }
+    }) => {
+      n(i), f(v), p(s), y(d), m(c), t(!0);
+    },
+    []
+  ), S = j(
+    (i, v) => {
+      v !== "clickaway" && t(!1);
+    },
+    []
+  ), l = j(
+    (i, v) => {
+      v !== "clickaway" && t(!1);
+    },
+    []
+  );
+  return {
+    showAlertMessage: k,
+    snackBar: /* @__PURE__ */ a(
+      ce,
+      {
+        anchorOrigin: h,
+        autoHideDuration: u,
+        open: o,
+        onClose: l,
+        TransitionComponent: g === "left" ? Xe : g === "right" ? Ke : g === "up" ? Ze : Ye,
+        children: /* @__PURE__ */ a(ae, { variant: "filled", onClose: S, severity: C, children: /* @__PURE__ */ a("div", { dangerouslySetInnerHTML: { __html: r } }) })
+      }
+    )
+  };
+};
+export {
+  fo as useSnackBar
+};