@hai-dev/ui-kit 1.0.5 → 1.0.7

package/dist/CircularProgress-BQQkuSse.js

@@ -0,0 +1,273 @@
+import * as O from "react";
+import { g as N, a as j, c as R, b as l, P as e } from "./createTheme-RvzX1VSA.js";
+import { m as g, c as U } from "./createSimplePaletteValueFilter-nb0wSOzC.js";
+import { jsx as y, jsxs as E } from "react/jsx-runtime";
+import { u as I, s as p, c as z, a as w, k as T, b as F } from "./chainPropTypes-KIxDwPzf.js";
+function V(r) {
+  return N("MuiCircularProgress", r);
+}
+j("MuiCircularProgress", ["root", "determinate", "indeterminate", "colorPrimary", "colorSecondary", "svg", "track", "circle", "circleDeterminate", "circleIndeterminate", "circleDisableShrink"]);
+const a = 44, k = T`
+  0% {
+    transform: rotate(0deg);
+  }
+
+  100% {
+    transform: rotate(360deg);
+  }
+`, v = T`
+  0% {
+    stroke-dasharray: 1px, 200px;
+    stroke-dashoffset: 0;
+  }
+
+  50% {
+    stroke-dasharray: 100px, 200px;
+    stroke-dashoffset: -15px;
+  }
+
+  100% {
+    stroke-dasharray: 1px, 200px;
+    stroke-dashoffset: -126px;
+  }
+`, A = typeof k != "string" ? w`
+        animation: ${k} 1.4s linear infinite;
+      ` : null, K = typeof v != "string" ? w`
+        animation: ${v} 1.4s ease-in-out infinite;
+      ` : null, W = (r) => {
+  const {
+    classes: t,
+    variant: s,
+    color: n,
+    disableShrink: m
+  } = r, u = {
+    root: ["root", s, `color${l(n)}`],
+    svg: ["svg"],
+    track: ["track"],
+    circle: ["circle", `circle${l(s)}`, m && "circleDisableShrink"]
+  };
+  return z(u, V, t);
+}, B = p("span", {
+  name: "MuiCircularProgress",
+  slot: "Root",
+  overridesResolver: (r, t) => {
+    const {
+      ownerState: s
+    } = r;
+    return [t.root, t[s.variant], t[`color${l(s.color)}`]];
+  }
+})(g(({
+  theme: r
+}) => ({
+  display: "inline-block",
+  variants: [{
+    props: {
+      variant: "determinate"
+    },
+    style: {
+      transition: r.transitions.create("transform")
+    }
+  }, {
+    props: {
+      variant: "indeterminate"
+    },
+    style: A || {
+      animation: `${k} 1.4s linear infinite`
+    }
+  }, ...Object.entries(r.palette).filter(U()).map(([t]) => ({
+    props: {
+      color: t
+    },
+    style: {
+      color: (r.vars || r).palette[t].main
+    }
+  }))]
+}))), G = p("svg", {
+  name: "MuiCircularProgress",
+  slot: "Svg"
+})({
+  display: "block"
+  // Keeps the progress centered
+}), Y = p("circle", {
+  name: "MuiCircularProgress",
+  slot: "Circle",
+  overridesResolver: (r, t) => {
+    const {
+      ownerState: s
+    } = r;
+    return [t.circle, t[`circle${l(s.variant)}`], s.disableShrink && t.circleDisableShrink];
+  }
+})(g(({
+  theme: r
+}) => ({
+  stroke: "currentColor",
+  variants: [{
+    props: {
+      variant: "determinate"
+    },
+    style: {
+      transition: r.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: K || {
+      // At runtime for Pigment CSS, `bufferAnimation` will be null and the generated keyframe will be used.
+      animation: `${v} 1.4s ease-in-out infinite`
+    }
+  }]
+}))), Z = p("circle", {
+  name: "MuiCircularProgress",
+  slot: "Track"
+})(g(({
+  theme: r
+}) => ({
+  stroke: "currentColor",
+  opacity: (r.vars || r).palette.action.activatedOpacity
+}))), _ = /* @__PURE__ */ O.forwardRef(function(t, s) {
+  const n = I({
+    props: t,
+    name: "MuiCircularProgress"
+  }), {
+    className: m,
+    color: u = "primary",
+    disableShrink: $ = !1,
+    enableTrackSlot: b = !1,
+    size: f = 40,
+    style: D,
+    thickness: o = 3.6,
+    value: d = 0,
+    variant: S = "indeterminate",
+    ...M
+  } = n, i = {
+    ...n,
+    color: u,
+    disableShrink: $,
+    size: f,
+    thickness: o,
+    value: d,
+    variant: S,
+    enableTrackSlot: b
+  }, c = W(i), h = {}, C = {}, P = {};
+  if (S === "determinate") {
+    const x = 2 * Math.PI * ((a - o) / 2);
+    h.strokeDasharray = x.toFixed(3), P["aria-valuenow"] = Math.round(d), h.strokeDashoffset = `${((100 - d) / 100 * x).toFixed(3)}px`, C.transform = "rotate(-90deg)";
+  }
+  return /* @__PURE__ */ y(B, {
+    className: R(c.root, m),
+    style: {
+      width: f,
+      height: f,
+      ...C,
+      ...D
+    },
+    ownerState: i,
+    ref: s,
+    role: "progressbar",
+    ...P,
+    ...M,
+    children: /* @__PURE__ */ E(G, {
+      className: c.svg,
+      ownerState: i,
+      viewBox: `${a / 2} ${a / 2} ${a} ${a}`,
+      children: [b ? /* @__PURE__ */ y(Z, {
+        className: c.track,
+        ownerState: i,
+        cx: a,
+        cy: a,
+        r: (a - o) / 2,
+        fill: "none",
+        strokeWidth: o,
+        "aria-hidden": "true"
+      }) : null, /* @__PURE__ */ y(Y, {
+        className: c.circle,
+        style: h,
+        ownerState: i,
+        cx: a,
+        cy: a,
+        r: (a - o) / 2,
+        fill: "none",
+        strokeWidth: o
+      })]
+    })
+  });
+});
+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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.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: e.oneOfType([e.oneOf(["inherit", "primary", "secondary", "error", "info", "success", "warning"]), e.string]),
+  /**
+   * If `true`, the shrink animation is disabled.
+   * This only works if variant is `indeterminate`.
+   * @default false
+   */
+  disableShrink: F(e.bool, (r) => r.disableShrink && r.variant && r.variant !== "indeterminate" ? new Error("MUI: You have provided the `disableShrink` prop with a variant other than `indeterminate`. This will have no effect.") : null),
+  /**
+   * If `true`, a track circle slot is mounted to show a subtle background for the progress.
+   * The `size` and `thickness` apply to the track slot to be consistent with the progress circle.
+   * @default false
+   */
+  enableTrackSlot: e.bool,
+  /**
+   * 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: e.oneOfType([e.number, e.string]),
+  /**
+   * @ignore
+   */
+  style: e.object,
+  /**
+   * 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 thickness of the circle.
+   * @default 3.6
+   */
+  thickness: e.number,
+  /**
+   * The value of the progress indicator for the determinate variant.
+   * Value between 0 and 100.
+   * @default 0
+   */
+  value: e.number,
+  /**
+   * The variant to use.
+   * Use indeterminate when there is no progress value.
+   * @default 'indeterminate'
+   */
+  variant: e.oneOf(["determinate", "indeterminate"])
+});
+export {
+  _ as C
+};