jcicl 0.0.227 → 0.0.231

package/Stepper/Stepper.d.ts

@@ -0,0 +1,9 @@
+import { PropsWithChildren } from 'react';
+import { MobileStepperProps } from '@mui/material/MobileStepper';
+export type StepperProps = {
+    onNext?: () => void;
+    onFinish: () => void;
+    onBack?: () => void;
+} & Partial<MobileStepperProps>;
+declare const Stepper: React.FC<PropsWithChildren<StepperProps>>;
+export default Stepper;

package/Stepper/Stepper.js

@@ -0,0 +1,688 @@
+import { jsxs as S, jsx as l } from "react/jsx-runtime";
+import * as w from "react";
+import { useState as V, Children as j } from "react";
+import { n as K } from "../.chunks/emotion-styled.browser.esm.js";
+import { k as R, c as M } from "../.chunks/emotion-react.browser.esm.js";
+import { Button as I } from "../Button/Button.js";
+import x from "../theme.js";
+import { g as T, a as q, s as y, c, u as z, b as $, P as o, d as U, l as X, j as Y, k as F } from "../.chunks/DefaultPropsProvider.js";
+import { m as h } from "../.chunks/memoTheme.js";
+import { P as G } from "../.chunks/Paper.js";
+import { u as H } from "../.chunks/index.js";
+import { c as P } from "../.chunks/createSimplePaletteValueFilter.js";
+import { i as D } from "../.chunks/integerPropType.js";
+function J(e) {
+  return T("MuiLinearProgress", e);
+}
+q("MuiLinearProgress", ["root", "colorPrimary", "colorSecondary", "determinate", "indeterminate", "buffer", "query", "dashed", "dashedColorPrimary", "dashedColorSecondary", "bar", "barColorPrimary", "barColorSecondary", "bar1Indeterminate", "bar1Determinate", "bar1Buffer", "bar2Indeterminate", "bar2Buffer"]);
+const B = 4, O = R`
+  0% {
+    left: -35%;
+    right: 100%;
+  }
+
+  60% {
+    left: 100%;
+    right: -90%;
+  }
+
+  100% {
+    left: 100%;
+    right: -90%;
+  }
+`, Q = typeof O != "string" ? M`
+        animation: ${O} 2.1s cubic-bezier(0.65, 0.815, 0.735, 0.395) infinite;
+      ` : null, L = R`
+  0% {
+    left: -200%;
+    right: 100%;
+  }
+
+  60% {
+    left: 107%;
+    right: -8%;
+  }
+
+  100% {
+    left: 107%;
+    right: -8%;
+  }
+`, W = typeof L != "string" ? M`
+        animation: ${L} 2.1s cubic-bezier(0.165, 0.84, 0.44, 1) 1.15s infinite;
+      ` : null, N = R`
+  0% {
+    opacity: 1;
+    background-position: 0 -23px;
+  }
+
+  60% {
+    opacity: 0;
+    background-position: 0 -23px;
+  }
+
+  100% {
+    opacity: 1;
+    background-position: -200px -23px;
+  }
+`, Z = typeof N != "string" ? M`
+        animation: ${N} 3s infinite linear;
+      ` : null, rr = (e) => {
+  const {
+    classes: r,
+    variant: t,
+    color: a
+  } = e, p = {
+    root: ["root", `color${c(a)}`, t],
+    dashed: ["dashed", `dashedColor${c(a)}`],
+    bar1: ["bar", `barColor${c(a)}`, (t === "indeterminate" || t === "query") && "bar1Indeterminate", t === "determinate" && "bar1Determinate", t === "buffer" && "bar1Buffer"],
+    bar2: ["bar", t !== "buffer" && `barColor${c(a)}`, t === "buffer" && `color${c(a)}`, (t === "indeterminate" || t === "query") && "bar2Indeterminate", t === "buffer" && "bar2Buffer"]
+  };
+  return U(p, J, r);
+}, A = (e, r) => e.vars ? e.vars.palette.LinearProgress[`${r}Bg`] : e.palette.mode === "light" ? X(e.palette[r].main, 0.62) : Y(e.palette[r].main, 0.5), er = y("span", {
+  name: "MuiLinearProgress",
+  slot: "Root",
+  overridesResolver: (e, r) => {
+    const {
+      ownerState: t
+    } = e;
+    return [r.root, r[`color${c(t.color)}`], r[t.variant]];
+  }
+})(h(({
+  theme: e
+}) => ({
+  position: "relative",
+  overflow: "hidden",
+  display: "block",
+  height: 4,
+  // Fix Safari's bug during composition of different paint.
+  zIndex: 0,
+  "@media print": {
+    colorAdjust: "exact"
+  },
+  variants: [...Object.entries(e.palette).filter(P()).map(([r]) => ({
+    props: {
+      color: r
+    },
+    style: {
+      backgroundColor: A(e, r)
+    }
+  })), {
+    props: ({
+      ownerState: r
+    }) => r.color === "inherit" && r.variant !== "buffer",
+    style: {
+      "&::before": {
+        content: '""',
+        position: "absolute",
+        left: 0,
+        top: 0,
+        right: 0,
+        bottom: 0,
+        backgroundColor: "currentColor",
+        opacity: 0.3
+      }
+    }
+  }, {
+    props: {
+      variant: "buffer"
+    },
+    style: {
+      backgroundColor: "transparent"
+    }
+  }, {
+    props: {
+      variant: "query"
+    },
+    style: {
+      transform: "rotate(180deg)"
+    }
+  }]
+}))), tr = y("span", {
+  name: "MuiLinearProgress",
+  slot: "Dashed",
+  overridesResolver: (e, r) => {
+    const {
+      ownerState: t
+    } = e;
+    return [r.dashed, r[`dashedColor${c(t.color)}`]];
+  }
+})(h(({
+  theme: e
+}) => ({
+  position: "absolute",
+  marginTop: 0,
+  height: "100%",
+  width: "100%",
+  backgroundSize: "10px 10px",
+  backgroundPosition: "0 -23px",
+  variants: [{
+    props: {
+      color: "inherit"
+    },
+    style: {
+      opacity: 0.3,
+      backgroundImage: "radial-gradient(currentColor 0%, currentColor 16%, transparent 42%)"
+    }
+  }, ...Object.entries(e.palette).filter(P()).map(([r]) => {
+    const t = A(e, r);
+    return {
+      props: {
+        color: r
+      },
+      style: {
+        backgroundImage: `radial-gradient(${t} 0%, ${t} 16%, transparent 42%)`
+      }
+    };
+  })]
+})), Z || {
+  // At runtime for Pigment CSS, `bufferAnimation` will be null and the generated keyframe will be used.
+  animation: `${N} 3s infinite linear`
+}), or = y("span", {
+  name: "MuiLinearProgress",
+  slot: "Bar1",
+  overridesResolver: (e, r) => {
+    const {
+      ownerState: t
+    } = e;
+    return [r.bar, r[`barColor${c(t.color)}`], (t.variant === "indeterminate" || t.variant === "query") && r.bar1Indeterminate, t.variant === "determinate" && r.bar1Determinate, t.variant === "buffer" && r.bar1Buffer];
+  }
+})(h(({
+  theme: e
+}) => ({
+  width: "100%",
+  position: "absolute",
+  left: 0,
+  bottom: 0,
+  top: 0,
+  transition: "transform 0.2s linear",
+  transformOrigin: "left",
+  variants: [{
+    props: {
+      color: "inherit"
+    },
+    style: {
+      backgroundColor: "currentColor"
+    }
+  }, ...Object.entries(e.palette).filter(P()).map(([r]) => ({
+    props: {
+      color: r
+    },
+    style: {
+      backgroundColor: (e.vars || e).palette[r].main
+    }
+  })), {
+    props: {
+      variant: "determinate"
+    },
+    style: {
+      transition: `transform .${B}s linear`
+    }
+  }, {
+    props: {
+      variant: "buffer"
+    },
+    style: {
+      zIndex: 1,
+      transition: `transform .${B}s linear`
+    }
+  }, {
+    props: ({
+      ownerState: r
+    }) => r.variant === "indeterminate" || r.variant === "query",
+    style: {
+      width: "auto"
+    }
+  }, {
+    props: ({
+      ownerState: r
+    }) => r.variant === "indeterminate" || r.variant === "query",
+    style: Q || {
+      animation: `${O} 2.1s cubic-bezier(0.65, 0.815, 0.735, 0.395) infinite`
+    }
+  }]
+}))), ar = y("span", {
+  name: "MuiLinearProgress",
+  slot: "Bar2",
+  overridesResolver: (e, r) => {
+    const {
+      ownerState: t
+    } = e;
+    return [r.bar, r[`barColor${c(t.color)}`], (t.variant === "indeterminate" || t.variant === "query") && r.bar2Indeterminate, t.variant === "buffer" && r.bar2Buffer];
+  }
+})(h(({
+  theme: e
+}) => ({
+  width: "100%",
+  position: "absolute",
+  left: 0,
+  bottom: 0,
+  top: 0,
+  transition: "transform 0.2s linear",
+  transformOrigin: "left",
+  variants: [...Object.entries(e.palette).filter(P()).map(([r]) => ({
+    props: {
+      color: r
+    },
+    style: {
+      "--LinearProgressBar2-barColor": (e.vars || e).palette[r].main
+    }
+  })), {
+    props: ({
+      ownerState: r
+    }) => r.variant !== "buffer" && r.color !== "inherit",
+    style: {
+      backgroundColor: "var(--LinearProgressBar2-barColor, currentColor)"
+    }
+  }, {
+    props: ({
+      ownerState: r
+    }) => r.variant !== "buffer" && r.color === "inherit",
+    style: {
+      backgroundColor: "currentColor"
+    }
+  }, {
+    props: {
+      color: "inherit"
+    },
+    style: {
+      opacity: 0.3
+    }
+  }, ...Object.entries(e.palette).filter(P()).map(([r]) => ({
+    props: {
+      color: r,
+      variant: "buffer"
+    },
+    style: {
+      backgroundColor: A(e, r),
+      transition: `transform .${B}s linear`
+    }
+  })), {
+    props: ({
+      ownerState: r
+    }) => r.variant === "indeterminate" || r.variant === "query",
+    style: {
+      width: "auto"
+    }
+  }, {
+    props: ({
+      ownerState: r
+    }) => r.variant === "indeterminate" || r.variant === "query",
+    style: W || {
+      animation: `${L} 2.1s cubic-bezier(0.165, 0.84, 0.44, 1) 1.15s infinite`
+    }
+  }]
+}))), E = /* @__PURE__ */ w.forwardRef(function(r, t) {
+  const a = z({
+    props: r,
+    name: "MuiLinearProgress"
+  }), {
+    className: p,
+    color: f = "primary",
+    value: b,
+    valueBuffer: m,
+    variant: d = "indeterminate",
+    ...C
+  } = a, i = {
+    ...a,
+    color: f,
+    variant: d
+  }, s = rr(i), g = H(), u = {}, v = {
+    bar1: {},
+    bar2: {}
+  };
+  if (d === "determinate" || d === "buffer")
+    if (b !== void 0) {
+      u["aria-valuenow"] = Math.round(b), u["aria-valuemin"] = 0, u["aria-valuemax"] = 100;
+      let n = b - 100;
+      g && (n = -n), v.bar1.transform = `translateX(${n}%)`;
+    } else process.env.NODE_ENV !== "production" && console.error("MUI: You need to provide a value prop when using the determinate or buffer variant of LinearProgress .");
+  if (d === "buffer")
+    if (m !== void 0) {
+      let n = (m || 0) - 100;
+      g && (n = -n), v.bar2.transform = `translateX(${n}%)`;
+    } else process.env.NODE_ENV !== "production" && console.error("MUI: You need to provide a valueBuffer prop when using the buffer variant of LinearProgress.");
+  return /* @__PURE__ */ S(er, {
+    className: $(s.root, p),
+    ownerState: i,
+    role: "progressbar",
+    ...u,
+    ref: t,
+    ...C,
+    children: [d === "buffer" ? /* @__PURE__ */ l(tr, {
+      className: s.dashed,
+      ownerState: i
+    }) : null, /* @__PURE__ */ l(or, {
+      className: s.bar1,
+      ownerState: i,
+      style: v.bar1
+    }), d === "determinate" ? null : /* @__PURE__ */ l(ar, {
+      className: s.bar2,
+      ownerState: i,
+      style: v.bar2
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (E.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: o.object,
+  /**
+   * @ignore
+   */
+  className: o.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: o.oneOfType([o.oneOf(["inherit", "primary", "secondary"]), o.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: o.oneOfType([o.arrayOf(o.oneOfType([o.func, o.object, o.bool])), o.func, o.object]),
+  /**
+   * The value of the progress indicator for the determinate and buffer variants.
+   * Value between 0 and 100.
+   */
+  value: o.number,
+  /**
+   * The value for the buffer variant.
+   * Value between 0 and 100.
+   */
+  valueBuffer: o.number,
+  /**
+   * The variant to use.
+   * Use indeterminate or query when there is no progress value.
+   * @default 'indeterminate'
+   */
+  variant: o.oneOf(["buffer", "determinate", "indeterminate", "query"])
+});
+function nr(e) {
+  return T("MuiMobileStepper", e);
+}
+q("MuiMobileStepper", ["root", "positionBottom", "positionTop", "positionStatic", "dots", "dot", "dotActive", "progress"]);
+const ir = (e) => {
+  const {
+    classes: r,
+    position: t
+  } = e, a = {
+    root: ["root", `position${c(t)}`],
+    dots: ["dots"],
+    dot: ["dot"],
+    dotActive: ["dotActive"],
+    progress: ["progress"]
+  };
+  return U(a, nr, r);
+}, sr = y(G, {
+  name: "MuiMobileStepper",
+  slot: "Root",
+  overridesResolver: (e, r) => {
+    const {
+      ownerState: t
+    } = e;
+    return [r.root, r[`position${c(t.position)}`]];
+  }
+})(h(({
+  theme: e
+}) => ({
+  display: "flex",
+  flexDirection: "row",
+  justifyContent: "space-between",
+  alignItems: "center",
+  background: (e.vars || e).palette.background.default,
+  padding: 8,
+  variants: [{
+    props: ({
+      position: r
+    }) => r === "top" || r === "bottom",
+    style: {
+      position: "fixed",
+      left: 0,
+      right: 0,
+      zIndex: (e.vars || e).zIndex.mobileStepper
+    }
+  }, {
+    props: {
+      position: "top"
+    },
+    style: {
+      top: 0
+    }
+  }, {
+    props: {
+      position: "bottom"
+    },
+    style: {
+      bottom: 0
+    }
+  }]
+}))), lr = y("div", {
+  name: "MuiMobileStepper",
+  slot: "Dots",
+  overridesResolver: (e, r) => r.dots
+})({
+  variants: [{
+    props: {
+      variant: "dots"
+    },
+    style: {
+      display: "flex",
+      flexDirection: "row"
+    }
+  }]
+}), pr = y("div", {
+  name: "MuiMobileStepper",
+  slot: "Dot",
+  shouldForwardProp: (e) => F(e) && e !== "dotActive",
+  overridesResolver: (e, r) => {
+    const {
+      dotActive: t
+    } = e;
+    return [r.dot, t && r.dotActive];
+  }
+})(h(({
+  theme: e
+}) => ({
+  variants: [{
+    props: {
+      variant: "dots"
+    },
+    style: {
+      transition: e.transitions.create("background-color", {
+        duration: e.transitions.duration.shortest
+      }),
+      backgroundColor: (e.vars || e).palette.action.disabled,
+      borderRadius: "50%",
+      width: 8,
+      height: 8,
+      margin: "0 2px"
+    }
+  }, {
+    props: {
+      variant: "dots",
+      dotActive: !0
+    },
+    style: {
+      backgroundColor: (e.vars || e).palette.primary.main
+    }
+  }]
+}))), cr = y(E, {
+  name: "MuiMobileStepper",
+  slot: "Progress",
+  overridesResolver: (e, r) => r.progress
+})({
+  variants: [{
+    props: {
+      variant: "progress"
+    },
+    style: {
+      width: "50%"
+    }
+  }]
+}), _ = /* @__PURE__ */ w.forwardRef(function(r, t) {
+  const a = z({
+    props: r,
+    name: "MuiMobileStepper"
+  }), {
+    activeStep: p = 0,
+    backButton: f,
+    className: b,
+    LinearProgressProps: m,
+    nextButton: d,
+    position: C = "bottom",
+    steps: i,
+    variant: s = "dots",
+    ...g
+  } = a, u = {
+    ...a,
+    activeStep: p,
+    position: C,
+    variant: s
+  };
+  let v;
+  s === "progress" && (i === 1 ? v = 100 : v = Math.ceil(p / (i - 1) * 100));
+  const n = ir(u);
+  return /* @__PURE__ */ S(sr, {
+    square: !0,
+    elevation: 0,
+    className: $(n.root, b),
+    ref: t,
+    ownerState: u,
+    ...g,
+    children: [f, s === "text" && /* @__PURE__ */ S(w.Fragment, {
+      children: [p + 1, " / ", i]
+    }), s === "dots" && /* @__PURE__ */ l(lr, {
+      ownerState: u,
+      className: n.dots,
+      children: [...new Array(i)].map((ur, k) => /* @__PURE__ */ l(pr, {
+        className: $(n.dot, k === p && n.dotActive),
+        ownerState: u,
+        dotActive: k === p
+      }, k))
+    }), s === "progress" && /* @__PURE__ */ l(cr, {
+      ownerState: u,
+      className: n.progress,
+      variant: "determinate",
+      value: v,
+      ...m
+    }), d]
+  });
+});
+process.env.NODE_ENV !== "production" && (_.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Set the active step (zero based index).
+   * Defines which dot is highlighted when the variant is 'dots'.
+   * @default 0
+   */
+  activeStep: D,
+  /**
+   * A back button element. For instance, it can be a `Button` or an `IconButton`.
+   */
+  backButton: o.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object,
+  /**
+   * @ignore
+   */
+  className: o.string,
+  /**
+   * Props applied to the `LinearProgress` element.
+   */
+  LinearProgressProps: o.object,
+  /**
+   * A next button element. For instance, it can be a `Button` or an `IconButton`.
+   */
+  nextButton: o.node,
+  /**
+   * Set the positioning type.
+   * @default 'bottom'
+   */
+  position: o.oneOf(["bottom", "static", "top"]),
+  /**
+   * The total steps.
+   */
+  steps: D.isRequired,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: o.oneOfType([o.arrayOf(o.oneOfType([o.func, o.object, o.bool])), o.func, o.object]),
+  /**
+   * The variant to use.
+   * @default 'dots'
+   */
+  variant: o.oneOf(["dots", "progress", "text"])
+});
+const dr = K("div")(() => ({
+  ...M`
+    position: relative;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    width: 100%;
+    height: 100%;
+    justify-content: space-between;
+    padding: 0;
+    margin: 0;
+    background-color: transparent;
+
+    .MuiPaper-root {
+      width: 100%;
+      background-color: transparent;
+      color: inherit;
+      padding: 9px 13px;
+    }
+
+    .MuiLinearProgress-root {
+      padding: 9px;
+      margin: 0 9px;
+      background-color: ${x.colors.whiteGreenA};
+      border-color: ${x.colors.green};
+
+      .MuiLinearProgress-bar {
+        background-color: ${x.colors.green};
+      }
+    }
+  `
+})), xr = ({
+  onNext: e,
+  onBack: r,
+  onFinish: t,
+  children: a,
+  ...p
+}) => {
+  const [f, b] = V(0), m = j.toArray(a).length, d = () => {
+    f === m - 1 ? t == null || t() : (b((g) => g + 1), e == null || e());
+  }, C = () => {
+    b((g) => g - 1), r == null || r();
+  }, i = () => /* @__PURE__ */ l(I, { onClick: d, children: f === m - 1 ? "Finish" : "Next" }), s = () => /* @__PURE__ */ l(I, { onClick: C, children: "Back" });
+  return /* @__PURE__ */ S(dr, { className: "jcStepContainer", children: [
+    j.toArray(a)[f] ?? null,
+    /* @__PURE__ */ l(
+      _,
+      {
+        variant: "progress",
+        steps: m,
+        position: "static",
+        activeStep: f,
+        nextButton: /* @__PURE__ */ l(i, {}),
+        backButton: f === 0 ? /* @__PURE__ */ l("div", { style: { width: "103px" } }) : /* @__PURE__ */ l(s, {}),
+        ...p
+      }
+    )
+  ] });
+};
+export {
+  xr as default
+};

package/Stepper/index.d.ts

@@ -0,0 +1 @@
+export { default, type StepperProps } from './Stepper';

package/Stepper/index.js

@@ -0,0 +1,4 @@
+import { default as o } from "./Stepper.js";
+export {
+  o as default
+};