@notificationapi/react 1.4.0 → 1.5.0

package/dist/assets/Stack.js

@@ -0,0 +1,216 @@
+import * as l from "react";
+import { o as S, r as V, P as e, p as N, q as g, t as m, v as D, w as E, x as R, c as w, b as B, e as M, y as h, s as G, u as U } from "./DefaultPropsProvider.js";
+import { jsx as _ } from "react/jsx-runtime";
+import { e as $ } from "./Typography.js";
+import { u as A } from "./useTheme2.js";
+const q = S();
+function L(o) {
+  const {
+    theme: r,
+    name: n,
+    props: t
+  } = o;
+  return !r || !r.components || !r.components[n] || !r.components[n].defaultProps ? t : V(r.components[n].defaultProps, t);
+}
+function z({
+  props: o,
+  name: r,
+  defaultTheme: n,
+  themeId: t
+}) {
+  let s = A(n);
+  return t && (s = s[t] || s), L({
+    theme: s,
+    name: r,
+    props: o
+  });
+}
+function ne(...o) {
+  return o.reduce((r, n) => n == null ? r : function(...s) {
+    r.apply(this, s), n.apply(this, s);
+  }, () => {
+  });
+}
+const H = N(), I = q("div", {
+  name: "MuiStack",
+  slot: "Root",
+  overridesResolver: (o, r) => r.root
+});
+function J(o) {
+  return z({
+    props: o,
+    name: "MuiStack",
+    defaultTheme: H
+  });
+}
+function K(o, r) {
+  const n = l.Children.toArray(o).filter(Boolean);
+  return n.reduce((t, s, i) => (t.push(s), i < n.length - 1 && t.push(/* @__PURE__ */ l.cloneElement(r, {
+    key: `separator-${i}`
+  })), t), []);
+}
+const Q = (o) => ({
+  row: "Left",
+  "row-reverse": "Right",
+  column: "Top",
+  "column-reverse": "Bottom"
+})[o], W = ({
+  ownerState: o,
+  theme: r
+}) => {
+  let n = {
+    display: "flex",
+    flexDirection: "column",
+    ...g({
+      theme: r
+    }, m({
+      values: o.direction,
+      breakpoints: r.breakpoints.values
+    }), (t) => ({
+      flexDirection: t
+    }))
+  };
+  if (o.spacing) {
+    const t = D(r), s = Object.keys(r.breakpoints.values).reduce((c, a) => ((typeof o.spacing == "object" && o.spacing[a] != null || typeof o.direction == "object" && o.direction[a] != null) && (c[a] = !0), c), {}), i = m({
+      values: o.direction,
+      base: s
+    }), u = m({
+      values: o.spacing,
+      base: s
+    });
+    typeof i == "object" && Object.keys(i).forEach((c, a, p) => {
+      if (!i[c]) {
+        const f = a > 0 ? i[p[a - 1]] : "column";
+        i[c] = f;
+      }
+    }), n = E(n, g({
+      theme: r
+    }, u, (c, a) => o.useFlexGap ? {
+      gap: h(t, c)
+    } : {
+      // The useFlexGap={false} implement relies on each child to give up control of the margin.
+      // We need to reset the margin to avoid double spacing.
+      "& > :not(style):not(style)": {
+        margin: 0
+      },
+      "& > :not(style) ~ :not(style)": {
+        [`margin${Q(a ? i[a] : o.direction)}`]: h(t, c)
+      }
+    }));
+  }
+  return n = R(r.breakpoints, n), n;
+};
+function X(o = {}) {
+  const {
+    // This will allow adding custom styled fn (for example for custom sx style function)
+    createStyledComponent: r = I,
+    useThemeProps: n = J,
+    componentName: t = "MuiStack"
+  } = o, s = () => B({
+    root: ["root"]
+  }, (c) => M(t, c), {}), i = r(W), u = /* @__PURE__ */ l.forwardRef(function(c, a) {
+    const p = n(c), y = $(p), {
+      component: f = "div",
+      direction: b = "column",
+      spacing: C = 0,
+      divider: v,
+      children: O,
+      className: x,
+      useFlexGap: j = !1,
+      ...k
+    } = y, P = {
+      direction: b,
+      spacing: C,
+      useFlexGap: j
+    }, F = s();
+    return /* @__PURE__ */ _(i, {
+      as: f,
+      ownerState: P,
+      ref: a,
+      className: w(F.root, x),
+      ...k,
+      children: v ? K(O, v) : O
+    });
+  });
+  return process.env.NODE_ENV !== "production" && (u.propTypes = {
+    children: e.node,
+    direction: e.oneOfType([e.oneOf(["column-reverse", "column", "row-reverse", "row"]), e.arrayOf(e.oneOf(["column-reverse", "column", "row-reverse", "row"])), e.object]),
+    divider: e.node,
+    spacing: e.oneOfType([e.arrayOf(e.oneOfType([e.number, e.string])), e.number, e.object, e.string]),
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+  }), u;
+}
+function te({
+  props: o,
+  states: r,
+  muiFormControl: n
+}) {
+  return r.reduce((t, s) => (t[s] = o[s], n && typeof o[s] > "u" && (t[s] = n[s]), t), {});
+}
+const T = /* @__PURE__ */ l.createContext(void 0);
+process.env.NODE_ENV !== "production" && (T.displayName = "FormControlContext");
+function se() {
+  return l.useContext(T);
+}
+const Y = X({
+  createStyledComponent: G("div", {
+    name: "MuiStack",
+    slot: "Root",
+    overridesResolver: (o, r) => r.root
+  }),
+  useThemeProps: (o) => U({
+    props: o,
+    name: "MuiStack"
+  })
+});
+process.env.NODE_ENV !== "production" && (Y.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * Defines the `flex-direction` style property.
+   * It is applied for all screen sizes.
+   * @default 'column'
+   */
+  direction: e.oneOfType([e.oneOf(["column-reverse", "column", "row-reverse", "row"]), e.arrayOf(e.oneOf(["column-reverse", "column", "row-reverse", "row"])), e.object]),
+  /**
+   * Add an element between each child.
+   */
+  divider: e.node,
+  /**
+   * Defines the space between immediate children.
+   * @default 0
+   */
+  spacing: e.oneOfType([e.arrayOf(e.oneOfType([e.number, e.string])), e.number, e.object, e.string]),
+  /**
+   * The system prop, which 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]),
+  /**
+   * If `true`, the CSS flexbox `gap` is used instead of applying `margin` to children.
+   *
+   * While CSS `gap` removes the [known limitations](https://mui.com/joy-ui/react-stack/#limitations),
+   * it is not fully supported in some browsers. We recommend checking https://caniuse.com/?search=flex%20gap before using this flag.
+   *
+   * To enable this flag globally, follow the [theme's default props](https://mui.com/material-ui/customization/theme-components/#default-props) configuration.
+   * @default false
+   */
+  useFlexGap: e.bool
+});
+export {
+  T as F,
+  Y as S,
+  ne as c,
+  te as f,
+  se as u
+};

package/dist/assets/Typography.js

@@ -1,48 +1,123 @@
-import * as P from "react";
-import { o as O, p as S, a as j, g as C, s as B, h as c, m as w, P as r, u as W, c as M, f as R } from "./DefaultPropsProvider.js";
-import { jsx as A } from "react/jsx-runtime";
-import { c as N } from "./createSimplePaletteValueFilter.js";
-const D = (e) => {
-  var a;
-  const o = {
+import * as E from "react";
+import { P as t, l as C, n as N, d as B, T as w, e as W, g as D, s as M, h as u, m as _, u as G, c as R, b as V } from "./DefaultPropsProvider.js";
+import { jsx as p } from "react/jsx-runtime";
+import { G as $, u as A } from "./useTheme2.js";
+import { c as U } from "./createSimplePaletteValueFilter.js";
+function k(o) {
+  return o == null || Object.keys(o).length === 0;
+}
+function T(o) {
+  const {
+    styles: r,
+    defaultTheme: e = {}
+  } = o;
+  return /* @__PURE__ */ p($, {
+    styles: typeof r == "function" ? (a) => r(k(a) ? e : a) : r
+  });
+}
+process.env.NODE_ENV !== "production" && (T.propTypes = {
+  defaultTheme: t.object,
+  styles: t.oneOfType([t.array, t.string, t.object, t.func])
+});
+function x({
+  styles: o,
+  themeId: r,
+  defaultTheme: e = {}
+}) {
+  const n = A(e), a = typeof o == "function" ? o(r && n[r] || n) : o;
+  return /* @__PURE__ */ p(T, {
+    styles: a
+  });
+}
+process.env.NODE_ENV !== "production" && (x.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  defaultTheme: t.object,
+  /**
+   * @ignore
+   */
+  styles: t.oneOfType([t.array, t.func, t.number, t.object, t.string, t.bool]),
+  /**
+   * @ignore
+   */
+  themeId: t.string
+});
+const H = (o) => {
+  var n;
+  const r = {
     systemProps: {},
     otherProps: {}
-  }, t = ((a = e == null ? void 0 : e.theme) == null ? void 0 : a.unstable_sxConfig) ?? O;
-  return Object.keys(e).forEach((n) => {
-    t[n] ? o.systemProps[n] = e[n] : o.otherProps[n] = e[n];
-  }), o;
+  }, e = ((n = o == null ? void 0 : o.theme) == null ? void 0 : n.unstable_sxConfig) ?? C;
+  return Object.keys(o).forEach((a) => {
+    e[a] ? r.systemProps[a] = o[a] : r.otherProps[a] = o[a];
+  }), r;
 };
-function E(e) {
+function z(o) {
   const {
-    sx: o,
-    ...t
-  } = e, {
-    systemProps: a,
-    otherProps: n
-  } = D(t);
+    sx: r,
+    ...e
+  } = o, {
+    systemProps: n,
+    otherProps: a
+  } = H(e);
   let s;
-  return Array.isArray(o) ? s = [a, ...o] : typeof o == "function" ? s = (...p) => {
-    const i = o(...p);
-    return S(i) ? {
-      ...a,
+  return Array.isArray(r) ? s = [n, ...r] : typeof r == "function" ? s = (...l) => {
+    const i = r(...l);
+    return N(i) ? {
+      ...n,
       ...i
-    } : a;
+    } : n;
   } : s = {
-    ...a,
-    ...o
-  }, {
     ...n,
+    ...r
+  }, {
+    ...a,
     sx: s
   };
 }
-function U() {
-  return E;
+function v(o) {
+  return /* @__PURE__ */ p(x, {
+    ...o,
+    defaultTheme: B,
+    themeId: w
+  });
+}
+process.env.NODE_ENV !== "production" && (v.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The styles you want to apply globally.
+   */
+  styles: t.oneOfType([t.array, t.func, t.number, t.object, t.string, t.bool])
+});
+function et(o) {
+  return function(e) {
+    return (
+      // Pigment CSS `globalCss` support callback with theme inside an object but `GlobalStyles` support theme as a callback value.
+      /* @__PURE__ */ p(v, {
+        styles: typeof o == "function" ? (n) => o({
+          theme: n,
+          ...e
+        }) : o
+      })
+    );
+  };
+}
+function F() {
+  return z;
 }
-function $(e) {
-  return j("MuiTypography", e);
+function I(o) {
+  return W("MuiTypography", o);
 }
-C("MuiTypography", ["root", "h1", "h2", "h3", "h4", "h5", "h6", "subtitle1", "subtitle2", "body1", "body2", "inherit", "button", "caption", "overline", "alignLeft", "alignRight", "alignCenter", "alignJustify", "noWrap", "gutterBottom", "paragraph"]);
-const V = {
+D("MuiTypography", ["root", "h1", "h2", "h3", "h4", "h5", "h6", "subtitle1", "subtitle2", "body1", "body2", "inherit", "button", "caption", "overline", "alignLeft", "alignRight", "alignCenter", "alignJustify", "noWrap", "gutterBottom", "paragraph"]);
+const J = {
   primary: !0,
   secondary: !0,
   error: !0,
@@ -52,31 +127,31 @@ const V = {
   textPrimary: !0,
   textSecondary: !0,
   textDisabled: !0
-}, _ = U(), k = (e) => {
+}, L = F(), q = (o) => {
   const {
-    align: o,
-    gutterBottom: t,
-    noWrap: a,
-    paragraph: n,
+    align: r,
+    gutterBottom: e,
+    noWrap: n,
+    paragraph: a,
     variant: s,
-    classes: p
-  } = e, i = {
-    root: ["root", s, e.align !== "inherit" && `align${c(o)}`, t && "gutterBottom", a && "noWrap", n && "paragraph"]
+    classes: l
+  } = o, i = {
+    root: ["root", s, o.align !== "inherit" && `align${u(r)}`, e && "gutterBottom", n && "noWrap", a && "paragraph"]
   };
-  return R(i, $, p);
-}, z = B("span", {
+  return V(i, I, l);
+}, K = M("span", {
   name: "MuiTypography",
   slot: "Root",
-  overridesResolver: (e, o) => {
+  overridesResolver: (o, r) => {
     const {
-      ownerState: t
-    } = e;
-    return [o.root, t.variant && o[t.variant], t.align !== "inherit" && o[`align${c(t.align)}`], t.noWrap && o.noWrap, t.gutterBottom && o.gutterBottom, t.paragraph && o.paragraph];
+      ownerState: e
+    } = o;
+    return [r.root, e.variant && r[e.variant], e.align !== "inherit" && r[`align${u(e.align)}`], e.noWrap && r.noWrap, e.gutterBottom && r.gutterBottom, e.paragraph && r.paragraph];
   }
-})(w(({
-  theme: e
+})(_(({
+  theme: o
 }) => {
-  var o;
+  var r;
   return {
     margin: 0,
     variants: [{
@@ -89,36 +164,36 @@ const V = {
         lineHeight: "inherit",
         letterSpacing: "inherit"
       }
-    }, ...Object.entries(e.typography).filter(([t, a]) => t !== "inherit" && a && typeof a == "object").map(([t, a]) => ({
+    }, ...Object.entries(o.typography).filter(([e, n]) => e !== "inherit" && n && typeof n == "object").map(([e, n]) => ({
       props: {
-        variant: t
+        variant: e
       },
-      style: a
-    })), ...Object.entries(e.palette).filter(N()).map(([t]) => ({
+      style: n
+    })), ...Object.entries(o.palette).filter(U()).map(([e]) => ({
       props: {
-        color: t
+        color: e
       },
       style: {
-        color: (e.vars || e).palette[t].main
+        color: (o.vars || o).palette[e].main
       }
-    })), ...Object.entries(((o = e.palette) == null ? void 0 : o.text) || {}).filter(([, t]) => typeof t == "string").map(([t]) => ({
+    })), ...Object.entries(((r = o.palette) == null ? void 0 : r.text) || {}).filter(([, e]) => typeof e == "string").map(([e]) => ({
       props: {
-        color: `text${c(t)}`
+        color: `text${u(e)}`
       },
       style: {
-        color: (e.vars || e).palette.text[t]
+        color: (o.vars || o).palette.text[e]
       }
     })), {
       props: ({
-        ownerState: t
-      }) => t.align !== "inherit",
+        ownerState: e
+      }) => e.align !== "inherit",
       style: {
         textAlign: "var(--Typography-textAlign)"
       }
     }, {
       props: ({
-        ownerState: t
-      }) => t.noWrap,
+        ownerState: e
+      }) => e.noWrap,
       style: {
         overflow: "hidden",
         textOverflow: "ellipsis",
@@ -126,21 +201,21 @@ const V = {
       }
     }, {
       props: ({
-        ownerState: t
-      }) => t.gutterBottom,
+        ownerState: e
+      }) => e.gutterBottom,
       style: {
         marginBottom: "0.35em"
       }
     }, {
       props: ({
-        ownerState: t
-      }) => t.paragraph,
+        ownerState: e
+      }) => e.paragraph,
       style: {
         marginBottom: 16
       }
     }]
   };
-})), b = {
+})), d = {
   h1: "h1",
   h2: "h2",
   h3: "h3",
@@ -152,55 +227,55 @@ const V = {
   body1: "p",
   body2: "p",
   inherit: "p"
-}, F = /* @__PURE__ */ P.forwardRef(function(o, t) {
+}, Q = /* @__PURE__ */ E.forwardRef(function(r, e) {
   const {
-    color: a,
-    ...n
-  } = W({
-    props: o,
+    color: n,
+    ...a
+  } = G({
+    props: r,
     name: "MuiTypography"
-  }), s = !V[a], p = _({
-    ...n,
+  }), s = !J[n], l = L({
+    ...a,
     ...s && {
-      color: a
+      color: n
     }
   }), {
     align: i = "inherit",
-    className: h,
-    component: y,
-    gutterBottom: x = !1,
-    noWrap: d = !1,
-    paragraph: g = !1,
-    variant: l = "body1",
-    variantMapping: u = b,
-    ...f
-  } = p, m = {
-    ...p,
+    className: y,
+    component: f,
+    gutterBottom: O = !1,
+    noWrap: S = !1,
+    paragraph: h = !1,
+    variant: c = "body1",
+    variantMapping: g = d,
+    ...m
+  } = l, b = {
+    ...l,
     align: i,
-    color: a,
-    className: h,
-    component: y,
-    gutterBottom: x,
-    noWrap: d,
-    paragraph: g,
-    variant: l,
-    variantMapping: u
-  }, v = y || (g ? "p" : u[l] || b[l]) || "span", T = k(m);
-  return /* @__PURE__ */ A(z, {
-    as: v,
-    ref: t,
-    className: M(T.root, h),
-    ...f,
-    ownerState: m,
+    color: n,
+    className: y,
+    component: f,
+    gutterBottom: O,
+    noWrap: S,
+    paragraph: h,
+    variant: c,
+    variantMapping: g
+  }, P = f || (h ? "p" : g[c] || d[c]) || "span", j = q(b);
+  return /* @__PURE__ */ p(K, {
+    as: P,
+    ref: e,
+    className: R(j.root, y),
+    ...m,
+    ownerState: b,
     style: {
       ...i !== "inherit" && {
         "--Typography-textAlign": i
       },
-      ...f.style
+      ...m.style
     }
   });
 });
-process.env.NODE_ENV !== "production" && (F.propTypes = {
+process.env.NODE_ENV !== "production" && (Q.propTypes = {
   // ┌────────────────────────────── Warning ──────────────────────────────┐
   // │ These PropTypes are generated from the TypeScript type definitions. │
   // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
@@ -209,35 +284,35 @@ process.env.NODE_ENV !== "production" && (F.propTypes = {
    * Set the text-align on the component.
    * @default 'inherit'
    */
-  align: r.oneOf(["center", "inherit", "justify", "left", "right"]),
+  align: t.oneOf(["center", "inherit", "justify", "left", "right"]),
   /**
    * The content of the component.
    */
-  children: r.node,
+  children: t.node,
   /**
    * Override or extend the styles applied to the component.
    */
-  classes: r.object,
+  classes: t.object,
   /**
    * @ignore
    */
-  className: r.string,
+  className: t.string,
   /**
    * The color of the component.
    * 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: r.oneOfType([r.oneOf(["primary", "secondary", "success", "error", "info", "warning", "textPrimary", "textSecondary", "textDisabled"]), r.string]),
+  color: t.oneOfType([t.oneOf(["primary", "secondary", "success", "error", "info", "warning", "textPrimary", "textSecondary", "textDisabled"]), t.string]),
   /**
    * The component used for the root node.
    * Either a string to use a HTML element or a component.
    */
-  component: r.elementType,
+  component: t.elementType,
   /**
    * If `true`, the text will have a bottom margin.
    * @default false
    */
-  gutterBottom: r.bool,
+  gutterBottom: t.bool,
   /**
    * If `true`, the text will not wrap, but instead will truncate with a text overflow ellipsis.
    *
@@ -245,26 +320,26 @@ process.env.NODE_ENV !== "production" && (F.propTypes = {
    * (the element needs to have a width in order to overflow).
    * @default false
    */
-  noWrap: r.bool,
+  noWrap: t.bool,
   /**
    * If `true`, the element will be a paragraph element.
    * @default false
    * @deprecated Use the `component` 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.
    */
-  paragraph: r.bool,
+  paragraph: t.bool,
   /**
    * @ignore
    */
-  style: r.object,
+  style: t.object,
   /**
    * The system prop that allows defining system overrides as well as additional CSS styles.
    */
-  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object]),
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
   /**
    * Applies the theme typography styles.
    * @default 'body1'
    */
-  variant: r.oneOfType([r.oneOf(["body1", "body2", "button", "caption", "h1", "h2", "h3", "h4", "h5", "h6", "inherit", "overline", "subtitle1", "subtitle2"]), r.string]),
+  variant: t.oneOfType([t.oneOf(["body1", "body2", "button", "caption", "h1", "h2", "h3", "h4", "h5", "h6", "inherit", "overline", "subtitle1", "subtitle2"]), t.string]),
   /**
    * The component maps the variant prop to a range of different HTML element types.
    * For instance, subtitle1 to `<h6>`.
@@ -284,9 +359,10 @@ process.env.NODE_ENV !== "production" && (F.propTypes = {
    *   inherit: 'p',
    * }
    */
-  variantMapping: r.object
+  variantMapping: t.object
 });
 export {
-  F as T,
-  E as e
+  Q as T,
+  z as e,
+  et as g
 };