kdpa-components 1.35.2 → 1.35.3

package/dist/Grid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/Grid/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC;AACjD,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/Grid/index.js

@@ -0,0 +1,17 @@
+import { j as t } from "../jsx-runtime-944c88e2.js";
+import { G as i } from "../Grid-c1f5fe6b.js";
+import "react";
+import "../extends-393586f3.js";
+import "../identifier-9dfe30d8.js";
+import "../emotion-memoize.esm-021d0d4e.js";
+import "../_commonjsHelpers-92157f1b.js";
+import "../useThemeProps-7d04a175.js";
+import "../emotion-is-prop-valid.esm-b7f48706.js";
+import "../useTheme-014a54ad.js";
+import "../extendSxProp-f7714a31.js";
+function G({ children: r, ...o }) {
+  return /* @__PURE__ */ t.jsx(i, { ...o, children: r });
+}
+export {
+  G as KdpaGrid
+};

package/dist/Grid-c1f5fe6b.js

@@ -0,0 +1,486 @@
+import { _ as g, a as D } from "./extends-393586f3.js";
+import * as S from "react";
+import { g as K, P as n, p as v, q as T } from "./identifier-9dfe30d8.js";
+import { g as I, s as L, u as q, c as U, a as F } from "./useThemeProps-7d04a175.js";
+import { u as Z } from "./useTheme-014a54ad.js";
+import { j } from "./jsx-runtime-944c88e2.js";
+import { e as A } from "./extendSxProp-f7714a31.js";
+function H(e, r) {
+  if (process.env.NODE_ENV === "production")
+    return () => null;
+  const t = r ? {
+    ...r.propTypes
+  } : null;
+  return (o) => (s, c, p, l, u, ...a) => {
+    const f = u || c, m = t == null ? void 0 : t[f];
+    if (m) {
+      const d = m(s, c, p, l, u, ...a);
+      if (d)
+        return d;
+    }
+    return typeof s[c] < "u" && !s[o] ? new Error(`The prop \`${f}\` of \`${e}\` can only be used together with the \`${o}\` prop.`) : null;
+  };
+}
+const E = /* @__PURE__ */ S.createContext();
+process.env.NODE_ENV !== "production" && (E.displayName = "GridContext");
+const C = E;
+function J(e) {
+  return K("MuiGrid", e);
+}
+const Q = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], X = ["column-reverse", "column", "row-reverse", "row"], Y = ["nowrap", "wrap-reverse", "wrap"], b = ["auto", !0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], w = I("MuiGrid", [
+  "root",
+  "container",
+  "item",
+  "zeroMinWidth",
+  // spacings
+  ...Q.map((e) => `spacing-xs-${e}`),
+  // direction values
+  ...X.map((e) => `direction-xs-${e}`),
+  // wrap values
+  ...Y.map((e) => `wrap-xs-${e}`),
+  // grid sizes for all breakpoints
+  ...b.map((e) => `grid-xs-${e}`),
+  ...b.map((e) => `grid-sm-${e}`),
+  ...b.map((e) => `grid-md-${e}`),
+  ...b.map((e) => `grid-lg-${e}`),
+  ...b.map((e) => `grid-xl-${e}`)
+]), ee = ["className", "columns", "columnSpacing", "component", "container", "direction", "item", "rowSpacing", "spacing", "wrap", "zeroMinWidth"];
+function x(e) {
+  const r = parseFloat(e);
+  return `${r}${String(e).replace(String(r), "") || "px"}`;
+}
+function ne({
+  theme: e,
+  ownerState: r
+}) {
+  let t;
+  return e.breakpoints.keys.reduce((i, o) => {
+    let s = {};
+    if (r[o] && (t = r[o]), !t)
+      return i;
+    if (t === !0)
+      s = {
+        flexBasis: 0,
+        flexGrow: 1,
+        maxWidth: "100%"
+      };
+    else if (t === "auto")
+      s = {
+        flexBasis: "auto",
+        flexGrow: 0,
+        flexShrink: 0,
+        maxWidth: "none",
+        width: "auto"
+      };
+    else {
+      const c = v({
+        values: r.columns,
+        breakpoints: e.breakpoints.values
+      }), p = typeof c == "object" ? c[o] : c;
+      if (p == null)
+        return i;
+      const l = `${Math.round(t / p * 1e8) / 1e6}%`;
+      let u = {};
+      if (r.container && r.item && r.columnSpacing !== 0) {
+        const a = e.spacing(r.columnSpacing);
+        if (a !== "0px") {
+          const f = `calc(${l} + ${x(a)})`;
+          u = {
+            flexBasis: f,
+            maxWidth: f
+          };
+        }
+      }
+      s = g({
+        flexBasis: l,
+        flexGrow: 0,
+        maxWidth: l
+      }, u);
+    }
+    return e.breakpoints.values[o] === 0 ? Object.assign(i, s) : i[e.breakpoints.up(o)] = s, i;
+  }, {});
+}
+function re({
+  theme: e,
+  ownerState: r
+}) {
+  const t = v({
+    values: r.direction,
+    breakpoints: e.breakpoints.values
+  });
+  return T({
+    theme: e
+  }, t, (i) => {
+    const o = {
+      flexDirection: i
+    };
+    return i.indexOf("column") === 0 && (o[`& > .${w.item}`] = {
+      maxWidth: "none"
+    }), o;
+  });
+}
+function z({
+  breakpoints: e,
+  values: r
+}) {
+  let t = "";
+  Object.keys(r).forEach((o) => {
+    t === "" && r[o] !== 0 && (t = o);
+  });
+  const i = Object.keys(e).sort((o, s) => e[o] - e[s]);
+  return i.slice(0, i.indexOf(t));
+}
+function oe({
+  theme: e,
+  ownerState: r
+}) {
+  const {
+    container: t,
+    rowSpacing: i
+  } = r;
+  let o = {};
+  if (t && i !== 0) {
+    const s = v({
+      values: i,
+      breakpoints: e.breakpoints.values
+    });
+    let c;
+    typeof s == "object" && (c = z({
+      breakpoints: e.breakpoints.values,
+      values: s
+    })), o = T({
+      theme: e
+    }, s, (p, l) => {
+      var u;
+      const a = e.spacing(p);
+      return a !== "0px" ? {
+        marginTop: `-${x(a)}`,
+        [`& > .${w.item}`]: {
+          paddingTop: x(a)
+        }
+      } : (u = c) != null && u.includes(l) ? {} : {
+        marginTop: 0,
+        [`& > .${w.item}`]: {
+          paddingTop: 0
+        }
+      };
+    });
+  }
+  return o;
+}
+function te({
+  theme: e,
+  ownerState: r
+}) {
+  const {
+    container: t,
+    columnSpacing: i
+  } = r;
+  let o = {};
+  if (t && i !== 0) {
+    const s = v({
+      values: i,
+      breakpoints: e.breakpoints.values
+    });
+    let c;
+    typeof s == "object" && (c = z({
+      breakpoints: e.breakpoints.values,
+      values: s
+    })), o = T({
+      theme: e
+    }, s, (p, l) => {
+      var u;
+      const a = e.spacing(p);
+      return a !== "0px" ? {
+        width: `calc(100% + ${x(a)})`,
+        marginLeft: `-${x(a)}`,
+        [`& > .${w.item}`]: {
+          paddingLeft: x(a)
+        }
+      } : (u = c) != null && u.includes(l) ? {} : {
+        width: "100%",
+        marginLeft: 0,
+        [`& > .${w.item}`]: {
+          paddingLeft: 0
+        }
+      };
+    });
+  }
+  return o;
+}
+function ie(e, r, t = {}) {
+  if (!e || e <= 0)
+    return [];
+  if (typeof e == "string" && !Number.isNaN(Number(e)) || typeof e == "number")
+    return [t[`spacing-xs-${String(e)}`]];
+  const i = [];
+  return r.forEach((o) => {
+    const s = e[o];
+    Number(s) > 0 && i.push(t[`spacing-${o}-${String(s)}`]);
+  }), i;
+}
+const se = L("div", {
+  name: "MuiGrid",
+  slot: "Root",
+  overridesResolver: (e, r) => {
+    const {
+      ownerState: t
+    } = e, {
+      container: i,
+      direction: o,
+      item: s,
+      spacing: c,
+      wrap: p,
+      zeroMinWidth: l,
+      breakpoints: u
+    } = t;
+    let a = [];
+    i && (a = ie(c, u, r));
+    const f = [];
+    return u.forEach((m) => {
+      const d = t[m];
+      d && f.push(r[`grid-${m}-${String(d)}`]);
+    }), [r.root, i && r.container, s && r.item, l && r.zeroMinWidth, ...a, o !== "row" && r[`direction-xs-${String(o)}`], p !== "wrap" && r[`wrap-xs-${String(p)}`], ...f];
+  }
+})(({
+  ownerState: e
+}) => g({
+  boxSizing: "border-box"
+}, e.container && {
+  display: "flex",
+  flexWrap: "wrap",
+  width: "100%"
+}, e.item && {
+  margin: 0
+  // For instance, it's useful when used with a `figure` element.
+}, e.zeroMinWidth && {
+  minWidth: 0
+}, e.wrap !== "wrap" && {
+  flexWrap: e.wrap
+}), re, oe, te, ne);
+function ae(e, r) {
+  if (!e || e <= 0)
+    return [];
+  if (typeof e == "string" && !Number.isNaN(Number(e)) || typeof e == "number")
+    return [`spacing-xs-${String(e)}`];
+  const t = [];
+  return r.forEach((i) => {
+    const o = e[i];
+    if (Number(o) > 0) {
+      const s = `spacing-${i}-${String(o)}`;
+      t.push(s);
+    }
+  }), t;
+}
+const ce = (e) => {
+  const {
+    classes: r,
+    container: t,
+    direction: i,
+    item: o,
+    spacing: s,
+    wrap: c,
+    zeroMinWidth: p,
+    breakpoints: l
+  } = e;
+  let u = [];
+  t && (u = ae(s, l));
+  const a = [];
+  l.forEach((m) => {
+    const d = e[m];
+    d && a.push(`grid-${m}-${String(d)}`);
+  });
+  const f = {
+    root: ["root", t && "container", o && "item", p && "zeroMinWidth", ...u, i !== "row" && `direction-xs-${String(i)}`, c !== "wrap" && `wrap-xs-${String(c)}`, ...a]
+  };
+  return F(f, J, r);
+}, y = /* @__PURE__ */ S.forwardRef(function(r, t) {
+  const i = q({
+    props: r,
+    name: "MuiGrid"
+  }), {
+    breakpoints: o
+  } = Z(), s = A(i), {
+    className: c,
+    columns: p,
+    columnSpacing: l,
+    component: u = "div",
+    container: a = !1,
+    direction: f = "row",
+    item: m = !1,
+    rowSpacing: d,
+    spacing: O = 0,
+    wrap: P = "wrap",
+    zeroMinWidth: V = !1
+  } = s, $ = D(s, ee), M = d || O, B = l || O, R = S.useContext(C), k = a ? p || 12 : R, N = {}, G = g({}, $);
+  o.keys.forEach((h) => {
+    $[h] != null && (N[h] = $[h], delete G[h]);
+  });
+  const W = g({}, s, {
+    columns: k,
+    container: a,
+    direction: f,
+    item: m,
+    rowSpacing: M,
+    columnSpacing: B,
+    wrap: P,
+    zeroMinWidth: V,
+    spacing: O
+  }, N, {
+    breakpoints: o.keys
+  }), _ = ce(W);
+  return /* @__PURE__ */ j.jsx(C.Provider, {
+    value: k,
+    children: /* @__PURE__ */ j.jsx(se, g({
+      ownerState: W,
+      className: U(_.root, c),
+      as: u,
+      ref: t
+    }, G))
+  });
+});
+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 "yarn proptypes"     |
+  // ----------------------------------------------------------------------
+  /**
+   * The content of the component.
+   */
+  children: n.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: n.object,
+  /**
+   * @ignore
+   */
+  className: n.string,
+  /**
+   * The number of columns.
+   * @default 12
+   */
+  columns: n.oneOfType([n.arrayOf(n.number), n.number, n.object]),
+  /**
+   * Defines the horizontal space between the type `item` components.
+   * It overrides the value of the `spacing` prop.
+   */
+  columnSpacing: n.oneOfType([n.arrayOf(n.oneOfType([n.number, n.string])), n.number, n.object, n.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: n.elementType,
+  /**
+   * If `true`, the component will have the flex *container* behavior.
+   * You should be wrapping *items* with a *container*.
+   * @default false
+   */
+  container: n.bool,
+  /**
+   * Defines the `flex-direction` style property.
+   * It is applied for all screen sizes.
+   * @default 'row'
+   */
+  direction: n.oneOfType([n.oneOf(["column-reverse", "column", "row-reverse", "row"]), n.arrayOf(n.oneOf(["column-reverse", "column", "row-reverse", "row"])), n.object]),
+  /**
+   * If `true`, the component will have the flex *item* behavior.
+   * You should be wrapping *items* with a *container*.
+   * @default false
+   */
+  item: n.bool,
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `lg` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  lg: n.oneOfType([n.oneOf(["auto"]), n.number, n.bool]),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `md` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  md: n.oneOfType([n.oneOf(["auto"]), n.number, n.bool]),
+  /**
+   * Defines the vertical space between the type `item` components.
+   * It overrides the value of the `spacing` prop.
+   */
+  rowSpacing: n.oneOfType([n.arrayOf(n.oneOfType([n.number, n.string])), n.number, n.object, n.string]),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `sm` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  sm: n.oneOfType([n.oneOf(["auto"]), n.number, n.bool]),
+  /**
+   * Defines the space between the type `item` components.
+   * It can only be used on a type `container` component.
+   * @default 0
+   */
+  spacing: n.oneOfType([n.arrayOf(n.oneOfType([n.number, n.string])), n.number, n.object, n.string]),
+  /**
+   * 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]),
+  /**
+   * Defines the `flex-wrap` style property.
+   * It's applied for all screen sizes.
+   * @default 'wrap'
+   */
+  wrap: n.oneOf(["nowrap", "wrap-reverse", "wrap"]),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `xl` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  xl: n.oneOfType([n.oneOf(["auto"]), n.number, n.bool]),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for all the screen sizes with the lowest priority.
+   * @default false
+   */
+  xs: n.oneOfType([n.oneOf(["auto"]), n.number, n.bool]),
+  /**
+   * If `true`, it sets `min-width: 0` on the item.
+   * Refer to the limitations section of the documentation to better understand the use case.
+   * @default false
+   */
+  zeroMinWidth: n.bool
+});
+if (process.env.NODE_ENV !== "production") {
+  const e = H("Grid", y);
+  y["propTypes"] = g({}, y.propTypes, {
+    direction: e("container"),
+    lg: e("item"),
+    md: e("item"),
+    sm: e("item"),
+    spacing: e("container"),
+    wrap: e("container"),
+    xs: e("item"),
+    zeroMinWidth: e("item")
+  });
+}
+const ge = y;
+export {
+  ge as G
+};

package/dist/Grow-151a20f6.js

@@ -0,0 +1,193 @@
+import { a as k, _ as g } from "./extends-393586f3.js";
+import * as c from "react";
+import { P as n } from "./identifier-9dfe30d8.js";
+import { u as B } from "./useTheme-014a54ad.js";
+import { T as J, r as M, g as _ } from "./utils-129661c6.js";
+import { j as Q } from "./jsx-runtime-944c88e2.js";
+import { u as U } from "./useForkRef-0781dda0.js";
+import { e as X } from "./elementAcceptingRef-803dfd80.js";
+const Y = ["addEndListener", "appear", "children", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "style", "timeout", "TransitionComponent"];
+function x(m) {
+  return `scale(${m}, ${m ** 2})`;
+}
+const Z = {
+  entering: {
+    opacity: 1,
+    transform: x(1)
+  },
+  entered: {
+    opacity: 1,
+    transform: "none"
+  }
+}, h = typeof navigator < "u" && /^((?!chrome|android).)*(safari|mobile)/i.test(navigator.userAgent) && /(os |version\/)15(.|_)4/i.test(navigator.userAgent), y = /* @__PURE__ */ c.forwardRef(function(T, w) {
+  const {
+    addEndListener: R,
+    appear: D = !0,
+    children: l,
+    easing: b,
+    in: j,
+    onEnter: v,
+    onEntered: P,
+    onEntering: G,
+    onExit: A,
+    onExited: H,
+    onExiting: O,
+    style: p,
+    timeout: r = "auto",
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: C = J
+  } = T, F = k(T, Y), L = c.useRef(), E = c.useRef(), s = B(), d = c.useRef(null), $ = U(d, l.ref, w), a = (t) => (i) => {
+    if (t) {
+      const o = d.current;
+      i === void 0 ? t(o) : t(o, i);
+    }
+  }, N = a(G), S = a((t, i) => {
+    M(t);
+    const {
+      duration: o,
+      delay: f,
+      easing: e
+    } = _({
+      style: p,
+      timeout: r,
+      easing: b
+    }, {
+      mode: "enter"
+    });
+    let u;
+    r === "auto" ? (u = s.transitions.getAutoHeightDuration(t.clientHeight), E.current = u) : u = o, t.style.transition = [s.transitions.create("opacity", {
+      duration: u,
+      delay: f
+    }), s.transitions.create("transform", {
+      duration: h ? u : u * 0.666,
+      delay: f,
+      easing: e
+    })].join(","), v && v(t, i);
+  }), W = a(P), q = a(O), z = a((t) => {
+    const {
+      duration: i,
+      delay: o,
+      easing: f
+    } = _({
+      style: p,
+      timeout: r,
+      easing: b
+    }, {
+      mode: "exit"
+    });
+    let e;
+    r === "auto" ? (e = s.transitions.getAutoHeightDuration(t.clientHeight), E.current = e) : e = i, t.style.transition = [s.transitions.create("opacity", {
+      duration: e,
+      delay: o
+    }), s.transitions.create("transform", {
+      duration: h ? e : e * 0.666,
+      delay: h ? o : o || e * 0.333,
+      easing: f
+    })].join(","), t.style.opacity = 0, t.style.transform = x(0.75), A && A(t);
+  }), K = a(H), V = (t) => {
+    r === "auto" && (L.current = setTimeout(t, E.current || 0)), R && R(d.current, t);
+  };
+  return c.useEffect(() => () => {
+    clearTimeout(L.current);
+  }, []), /* @__PURE__ */ Q.jsx(C, g({
+    appear: D,
+    in: j,
+    nodeRef: d,
+    onEnter: S,
+    onEntered: W,
+    onEntering: N,
+    onExit: z,
+    onExited: K,
+    onExiting: q,
+    addEndListener: V,
+    timeout: r === "auto" ? null : r
+  }, F, {
+    children: (t, i) => /* @__PURE__ */ c.cloneElement(l, g({
+      style: g({
+        opacity: 0,
+        transform: x(0.75),
+        visibility: t === "exited" && !j ? "hidden" : void 0
+      }, Z[t], p, l.props.style),
+      ref: $
+    }, i))
+  }));
+});
+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 "yarn proptypes"     |
+  // ----------------------------------------------------------------------
+  /**
+   * Add a custom transition end trigger. Called with the transitioning DOM
+   * node and a done callback. Allows for more fine grained transition end
+   * logic. Note: Timeouts are still used as a fallback if provided.
+   */
+  addEndListener: n.func,
+  /**
+   * Perform the enter transition when it first mounts if `in` is also `true`.
+   * Set this to `false` to disable this behavior.
+   * @default true
+   */
+  appear: n.bool,
+  /**
+   * A single child content element.
+   */
+  children: X.isRequired,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: n.oneOfType([n.shape({
+    enter: n.string,
+    exit: n.string
+  }), n.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: n.bool,
+  /**
+   * @ignore
+   */
+  onEnter: n.func,
+  /**
+   * @ignore
+   */
+  onEntered: n.func,
+  /**
+   * @ignore
+   */
+  onEntering: n.func,
+  /**
+   * @ignore
+   */
+  onExit: n.func,
+  /**
+   * @ignore
+   */
+  onExited: n.func,
+  /**
+   * @ignore
+   */
+  onExiting: n.func,
+  /**
+   * @ignore
+   */
+  style: n.object,
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   *
+   * Set to 'auto' to automatically calculate transition time based on height.
+   * @default 'auto'
+   */
+  timeout: n.oneOfType([n.oneOf(["auto"]), n.number, n.shape({
+    appear: n.number,
+    enter: n.number,
+    exit: n.number
+  })])
+});
+y.muiSupportAuto = !0;
+const an = y;
+export {
+  an as G
+};

package/dist/HTMLElementType-ff213f3c.js

@@ -0,0 +1,9 @@
+function p(r, n, l, t, u) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const e = r[n], o = u || n;
+  return e == null ? null : e && e.nodeType !== 1 ? new Error(`Invalid ${t} \`${o}\` supplied to \`${l}\`. Expected an HTMLElement.`) : null;
+}
+export {
+  p as H
+};