@cgi-learning-hub/ui 1.3.5-dev.1738165321 → 1.3.5-dev.1739205895

package/dist/Button-CSNPv43f.js

@@ -0,0 +1,542 @@
+import { jsx as d, jsxs as U } from "react/jsx-runtime";
+import { u as M, s as f, c as E } from "./DefaultPropsProvider-CmOKr9hq.js";
+import * as k from "react";
+import { I as O, H as R, G as W, P as n } from "./generateUtilityClasses-v9KcqdK1.js";
+import { a as F, r as V, B as G } from "./Button-DovfjBkz.js";
+import { u as A } from "./useId-CK6Kn3Tn.js";
+import { c as u } from "./capitalize-yX_QSknw.js";
+import { m as S } from "./memoTheme-D-rebSfX.js";
+import { c as H } from "./createSimplePaletteValueFilter-B7--0ryQ.js";
+import { c as T } from "./chainPropTypes-D9lkm76m.js";
+import { css as D, keyframes as N } from "@emotion/react";
+function K(o) {
+  return O("MuiCircularProgress", o);
+}
+const ho = R("MuiCircularProgress", ["root", "determinate", "indeterminate", "colorPrimary", "colorSecondary", "svg", "circle", "circleDeterminate", "circleIndeterminate", "circleDisableShrink"]), c = 44, $ = N`
+  0% {
+    transform: rotate(0deg);
+  }
+
+  100% {
+    transform: rotate(360deg);
+  }
+`, w = N`
+  0% {
+    stroke-dasharray: 1px, 200px;
+    stroke-dashoffset: 0;
+  }
+
+  50% {
+    stroke-dasharray: 100px, 200px;
+    stroke-dashoffset: -15px;
+  }
+
+  100% {
+    stroke-dasharray: 100px, 200px;
+    stroke-dashoffset: -125px;
+  }
+`, _ = typeof $ != "string" ? D`
+        animation: ${$} 1.4s linear infinite;
+      ` : null, Y = typeof w != "string" ? D`
+        animation: ${w} 1.4s ease-in-out infinite;
+      ` : null, Z = (o) => {
+  const {
+    classes: t,
+    variant: r,
+    color: i,
+    disableShrink: g
+  } = o, a = {
+    root: ["root", r, `color${u(i)}`],
+    svg: ["svg"],
+    circle: ["circle", `circle${u(r)}`, g && "circleDisableShrink"]
+  };
+  return E(a, K, t);
+}, q = f("span", {
+  name: "MuiCircularProgress",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.root, t[r.variant], t[`color${u(r.color)}`]];
+  }
+})(S(({
+  theme: o
+}) => ({
+  display: "inline-block",
+  variants: [{
+    props: {
+      variant: "determinate"
+    },
+    style: {
+      transition: o.transitions.create("transform")
+    }
+  }, {
+    props: {
+      variant: "indeterminate"
+    },
+    style: _ || {
+      animation: `${$} 1.4s linear infinite`
+    }
+  }, ...Object.entries(o.palette).filter(H()).map(([t]) => ({
+    props: {
+      color: t
+    },
+    style: {
+      color: (o.vars || o).palette[t].main
+    }
+  }))]
+}))), J = f("svg", {
+  name: "MuiCircularProgress",
+  slot: "Svg",
+  overridesResolver: (o, t) => t.svg
+})({
+  display: "block"
+  // Keeps the progress centered
+}), Q = f("circle", {
+  name: "MuiCircularProgress",
+  slot: "Circle",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.circle, t[`circle${u(r.variant)}`], r.disableShrink && t.circleDisableShrink];
+  }
+})(S(({
+  theme: o
+}) => ({
+  stroke: "currentColor",
+  variants: [{
+    props: {
+      variant: "determinate"
+    },
+    style: {
+      transition: o.transitions.create("stroke-dashoffset")
+    }
+  }, {
+    props: {
+      variant: "indeterminate"
+    },
+    style: {
+      // Some default value that looks fine waiting for the animation to kicks in.
+      strokeDasharray: "80px, 200px",
+      strokeDashoffset: 0
+      // Add the unit to fix a Edge 16 and below bug.
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.variant === "indeterminate" && !t.disableShrink,
+    style: Y || {
+      // At runtime for Pigment CSS, `bufferAnimation` will be null and the generated keyframe will be used.
+      animation: `${w} 1.4s ease-in-out infinite`
+    }
+  }]
+}))), j = /* @__PURE__ */ k.forwardRef(function(t, r) {
+  const i = M({
+    props: t,
+    name: "MuiCircularProgress"
+  }), {
+    className: g,
+    color: a = "primary",
+    disableShrink: P = !1,
+    size: m = 40,
+    style: C,
+    thickness: s = 3.6,
+    value: b = 0,
+    variant: L = "indeterminate",
+    ...x
+  } = i, h = {
+    ...i,
+    color: a,
+    disableShrink: P,
+    size: m,
+    thickness: s,
+    value: b,
+    variant: L
+  }, y = Z(h), v = {}, l = {}, p = {};
+  if (L === "determinate") {
+    const I = 2 * Math.PI * ((c - s) / 2);
+    v.strokeDasharray = I.toFixed(3), p["aria-valuenow"] = Math.round(b), v.strokeDashoffset = `${((100 - b) / 100 * I).toFixed(3)}px`, l.transform = "rotate(-90deg)";
+  }
+  return /* @__PURE__ */ d(q, {
+    className: W(y.root, g),
+    style: {
+      width: m,
+      height: m,
+      ...l,
+      ...C
+    },
+    ownerState: h,
+    ref: r,
+    role: "progressbar",
+    ...p,
+    ...x,
+    children: /* @__PURE__ */ d(J, {
+      className: y.svg,
+      ownerState: h,
+      viewBox: `${c / 2} ${c / 2} ${c} ${c}`,
+      children: /* @__PURE__ */ d(Q, {
+        className: y.circle,
+        style: v,
+        ownerState: h,
+        cx: c,
+        cy: c,
+        r: (c - s) / 2,
+        fill: "none",
+        strokeWidth: s
+      })
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (j.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: n.object,
+  /**
+   * @ignore
+   */
+  className: n.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).
+   * @default 'primary'
+   */
+  color: n.oneOfType([n.oneOf(["inherit", "primary", "secondary", "error", "info", "success", "warning"]), n.string]),
+  /**
+   * If `true`, the shrink animation is disabled.
+   * This only works if variant is `indeterminate`.
+   * @default false
+   */
+  disableShrink: T(n.bool, (o) => o.disableShrink && o.variant && o.variant !== "indeterminate" ? new Error("MUI: You have provided the `disableShrink` prop with a variant other than `indeterminate`. This will have no effect.") : null),
+  /**
+   * The size of the component.
+   * If using a number, the pixel unit is assumed.
+   * If using a string, you need to provide the CSS unit, for example '3rem'.
+   * @default 40
+   */
+  size: n.oneOfType([n.number, n.string]),
+  /**
+   * @ignore
+   */
+  style: n.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: n.oneOfType([n.arrayOf(n.oneOfType([n.func, n.object, n.bool])), n.func, n.object]),
+  /**
+   * The thickness of the circle.
+   * @default 3.6
+   */
+  thickness: n.number,
+  /**
+   * The value of the progress indicator for the determinate variant.
+   * Value between 0 and 100.
+   * @default 0
+   */
+  value: n.number,
+  /**
+   * The variant to use.
+   * Use indeterminate when there is no progress value.
+   * @default 'indeterminate'
+   */
+  variant: n.oneOf(["determinate", "indeterminate"])
+});
+function X(o) {
+  return O("MuiLoadingButton", o);
+}
+const e = R("MuiLoadingButton", ["root", "label", "loading", "loadingIndicator", "loadingIndicatorCenter", "loadingIndicatorStart", "loadingIndicatorEnd", "endIconLoadingEnd", "startIconLoadingStart"]), oo = (o) => {
+  const {
+    loading: t,
+    loadingPosition: r,
+    classes: i
+  } = o, g = {
+    root: ["root", t && "loading"],
+    label: ["label"],
+    startIcon: [t && `startIconLoading${u(r)}`],
+    endIcon: [t && `endIconLoading${u(r)}`],
+    loadingIndicator: ["loadingIndicator", t && `loadingIndicator${u(r)}`]
+  }, a = E(g, X, i);
+  return {
+    ...i,
+    // forward the outlined, color, etc. classes to Button
+    ...a
+  };
+}, to = (o) => o !== "ownerState" && o !== "theme" && o !== "sx" && o !== "as" && o !== "classes", no = f(G, {
+  shouldForwardProp: (o) => to(o) || o === "classes",
+  name: "MuiLoadingButton",
+  slot: "Root",
+  overridesResolver: (o, t) => [t.root, t.startIconLoadingStart && {
+    [`& .${e.startIconLoadingStart}`]: t.startIconLoadingStart
+  }, t.endIconLoadingEnd && {
+    [`& .${e.endIconLoadingEnd}`]: t.endIconLoadingEnd
+  }]
+})(S(({
+  theme: o
+}) => ({
+  display: "inline-flex",
+  [`& .${e.startIconLoadingStart}, & .${e.endIconLoadingEnd}`]: {
+    transition: o.transitions.create(["opacity"], {
+      duration: o.transitions.duration.short
+    }),
+    opacity: 0
+  },
+  variants: [{
+    props: {
+      loadingPosition: "center"
+    },
+    style: {
+      transition: o.transitions.create(["background-color", "box-shadow", "border-color"], {
+        duration: o.transitions.duration.short
+      }),
+      [`&.${e.loading}`]: {
+        color: "transparent"
+      }
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.loadingPosition === "start" && t.fullWidth,
+    style: {
+      [`& .${e.startIconLoadingStart}, & .${e.endIconLoadingEnd}`]: {
+        transition: o.transitions.create(["opacity"], {
+          duration: o.transitions.duration.short
+        }),
+        opacity: 0,
+        marginRight: -8
+      }
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.loadingPosition === "end" && t.fullWidth,
+    style: {
+      [`& .${e.startIconLoadingStart}, & .${e.endIconLoadingEnd}`]: {
+        transition: o.transitions.create(["opacity"], {
+          duration: o.transitions.duration.short
+        }),
+        opacity: 0,
+        marginLeft: -8
+      }
+    }
+  }]
+}))), ro = f("span", {
+  name: "MuiLoadingButton",
+  slot: "LoadingIndicator",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.loadingIndicator, t[`loadingIndicator${u(r.loadingPosition)}`]];
+  }
+})(S(({
+  theme: o
+}) => ({
+  position: "absolute",
+  visibility: "visible",
+  display: "flex",
+  variants: [{
+    props: {
+      loadingPosition: "start",
+      size: "small"
+    },
+    style: {
+      left: 10
+    }
+  }, {
+    props: ({
+      loadingPosition: t,
+      ownerState: r
+    }) => t === "start" && r.size !== "small",
+    style: {
+      left: 14
+    }
+  }, {
+    props: {
+      variant: "text",
+      loadingPosition: "start"
+    },
+    style: {
+      left: 6
+    }
+  }, {
+    props: {
+      loadingPosition: "center"
+    },
+    style: {
+      left: "50%",
+      transform: "translate(-50%)",
+      color: (o.vars || o).palette.action.disabled
+    }
+  }, {
+    props: {
+      loadingPosition: "end",
+      size: "small"
+    },
+    style: {
+      right: 10
+    }
+  }, {
+    props: ({
+      loadingPosition: t,
+      ownerState: r
+    }) => t === "end" && r.size !== "small",
+    style: {
+      right: 14
+    }
+  }, {
+    props: {
+      variant: "text",
+      loadingPosition: "end"
+    },
+    style: {
+      right: 6
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.loadingPosition === "start" && t.fullWidth,
+    style: {
+      position: "relative",
+      left: -10
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.loadingPosition === "end" && t.fullWidth,
+    style: {
+      position: "relative",
+      right: -10
+    }
+  }]
+}))), B = f("span", {
+  name: "MuiLoadingButton",
+  slot: "Label",
+  overridesResolver: (o, t) => [t.label]
+})({
+  display: "inherit",
+  alignItems: "inherit",
+  justifyContent: "inherit"
+}), z = /* @__PURE__ */ k.forwardRef(function(t, r) {
+  const i = k.useContext(F), g = V(i, t), a = M({
+    props: g,
+    name: "MuiLoadingButton"
+  }), {
+    children: P,
+    disabled: m = !1,
+    id: C,
+    loading: s = !1,
+    loadingIndicator: b,
+    loadingPosition: L = "center",
+    variant: x = "text",
+    ...h
+  } = a, y = A(C), v = b ?? /* @__PURE__ */ d(j, {
+    "aria-labelledby": y,
+    color: "inherit",
+    size: 16
+  }), l = {
+    ...a,
+    disabled: m,
+    loading: s,
+    loadingIndicator: v,
+    loadingPosition: L,
+    variant: x
+  }, p = oo(l), I = s ? /* @__PURE__ */ d(ro, {
+    className: p.loadingIndicator,
+    ownerState: l,
+    children: v
+  }) : null;
+  return /* @__PURE__ */ U(no, {
+    disabled: m || s,
+    id: y,
+    ref: r,
+    ...h,
+    variant: x,
+    classes: p,
+    ownerState: l,
+    children: [l.loadingPosition === "end" ? /* @__PURE__ */ d(B, {
+      className: p.label,
+      children: P
+    }) : I, l.loadingPosition === "end" ? I : /* @__PURE__ */ d(B, {
+      className: p.label,
+      children: P
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (z.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: n.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: n.object,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: n.bool,
+  /**
+   * @ignore
+   */
+  id: n.string,
+  /**
+   * If `true`, the loading indicator is shown and the button becomes disabled.
+   * @default false
+   */
+  loading: n.bool,
+  /**
+   * Element placed before the children if the button is in loading state.
+   * The node should contain an element with `role="progressbar"` with an accessible name.
+   * By default we render a `CircularProgress` that is labelled by the button itself.
+   * @default <CircularProgress color="inherit" size={16} />
+   */
+  loadingIndicator: n.node,
+  /**
+   * The loading indicator can be positioned on the start, end, or the center of the button.
+   * @default 'center'
+   */
+  loadingPosition: T(n.oneOf(["start", "end", "center"]), (o) => o.loadingPosition === "start" && !o.startIcon ? new Error('MUI: The loadingPosition="start" should be used in combination with startIcon.') : o.loadingPosition === "end" && !o.endIcon ? new Error('MUI: The loadingPosition="end" should be used in combination with endIcon.') : null),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: n.oneOfType([n.arrayOf(n.oneOfType([n.func, n.object, n.bool])), n.func, n.object]),
+  /**
+   * The variant to use.
+   * @default 'text'
+   */
+  variant: n.oneOfType([n.oneOf(["contained", "outlined", "text"]), n.string])
+});
+const io = f(z)(({ color: o, theme: t }) => ({
+  minHeight: 38,
+  textTransform: "none",
+  transition: "all 250ms cubic-bezier(0.4, 0, 0.2, 1) 0ms",
+  "&.MuiButton-outlined": {
+    borderRadius: 5,
+    borderWidth: 2
+    /* "&:hover": {
+      //backgroundColor: theme.palette[color].main,
+      color: theme.palette.common.white,
+    },*/
+  }
+})), yo = ({
+  variant: o = "outlined",
+  ...t
+}) => /* @__PURE__ */ d(io, { variant: o, ...t });
+export {
+  yo as B,
+  j as C,
+  ho as c,
+  K as g
+};

package/dist/{Button-DJ9kLggx.js → Button-DovfjBkz.js}

@@ -1,11 +1,11 @@
 import * as g from "react";
-import { I as L, H as G, n as v, G as m, P as t } from "./generateUtilityClasses-CMVTZlSt.js";
-import { s as f, r as D, u as F, c as U } from "./DefaultPropsProvider-CeEBQtDy.js";
-import { m as H } from "./memoTheme-CnIL9ySw.js";
+import { H as L, I as G, G as m, n as v, P as t } from "./generateUtilityClasses-v9KcqdK1.js";
+import { u as D, s as b, c as F, r as U } from "./DefaultPropsProvider-CmOKr9hq.js";
+import { m as H } from "./memoTheme-D-rebSfX.js";
 import { c as _ } from "./createSimplePaletteValueFilter-B7--0ryQ.js";
 import { jsxs as A, jsx as I } from "react/jsx-runtime";
-import { B as K } from "./ButtonBase-CGJRRTHm.js";
-import { c as s } from "./capitalize-B55K71yP.js";
+import { c as s } from "./capitalize-yX_QSknw.js";
+import { B as K } from "./ButtonBase-eQU9HVgU.js";
 function w(o, n) {
   const a = {
     ...n
@@ -58,7 +58,7 @@ const J = (o) => {
     label: ["label"],
     startIcon: ["icon", "startIcon", `iconSize${s(r)}`],
     endIcon: ["icon", "endIcon", `iconSize${s(r)}`]
-  }, p = U(c, q, l);
+  }, p = F(c, q, l);
   return {
     ...l,
     // forward the focused, disabled, etc. classes to the ButtonBase
@@ -91,8 +91,8 @@ const J = (o) => {
       fontSize: 22
     }
   }
-}], Q = f(K, {
-  shouldForwardProp: (o) => D(o) || o === "classes",
+}], Q = b(K, {
+  shouldForwardProp: (o) => U(o) || o === "classes",
   name: "MuiButton",
   slot: "Root",
   overridesResolver: (o, n) => {
@@ -287,7 +287,7 @@ const J = (o) => {
       }
     }]
   };
-})), X = f("span", {
+})), X = b("span", {
   name: "MuiButton",
   slot: "StartIcon",
   overridesResolver: (o, n) => {
@@ -308,7 +308,7 @@ const J = (o) => {
       marginLeft: -2
     }
   }, ...R]
-}), Y = f("span", {
+}), Y = b("span", {
   name: "MuiButton",
   slot: "EndIcon",
   overridesResolver: (o, n) => {
@@ -330,13 +330,13 @@ const J = (o) => {
     }
   }, ...R]
 }), Z = /* @__PURE__ */ g.forwardRef(function(n, a) {
-  const e = g.useContext($), r = g.useContext(O), i = w(e, n), l = F({
+  const e = g.useContext($), r = g.useContext(O), i = w(e, n), l = D({
     props: i,
     name: "MuiButton"
   }), {
     children: c,
     color: p = "primary",
-    component: b = "button",
+    component: f = "button",
     className: N,
     disabled: x = !1,
     disableElevation: h = !1,
@@ -352,7 +352,7 @@ const J = (o) => {
   } = l, y = {
     ...l,
     color: p,
-    component: b,
+    component: f,
     disabled: x,
     disableElevation: h,
     disableFocusRipple: S,
@@ -372,7 +372,7 @@ const J = (o) => {
   return /* @__PURE__ */ A(Q, {
     ownerState: y,
     className: m(e.className, u.root, N, j),
-    component: b,
+    component: f,
     disabled: x,
     focusRipple: !S,
     focusVisibleClassName: m(u.focusVisible, E),