kdpa-components 1.35.2 → 1.35.3

package/dist/Collapse-4b8b3146.js

@@ -0,0 +1,299 @@
+import { _ as r, a as te } from "./extends-393586f3.js";
+import * as u from "react";
+import { g as ne, s as b, u as oe, c as ie, a as re } from "./useThemeProps-7d04a175.js";
+import { g as se, n as ae, P as e } from "./identifier-9dfe30d8.js";
+import { T as le, g as _ } from "./utils-129661c6.js";
+import { u as pe } from "./useTheme-014a54ad.js";
+import { j as C } from "./jsx-runtime-944c88e2.js";
+import { u as ce } from "./useForkRef-0781dda0.js";
+import { e as ue } from "./elementTypeAcceptingRef-6c34f16b.js";
+function de(o) {
+  return se("MuiCollapse", o);
+}
+ne("MuiCollapse", ["root", "horizontal", "vertical", "entered", "hidden", "wrapper", "wrapperInner"]);
+const fe = ["addEndListener", "children", "className", "collapsedSize", "component", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "orientation", "style", "timeout", "TransitionComponent"], me = (o) => {
+  const {
+    orientation: n,
+    classes: s
+  } = o, d = {
+    root: ["root", `${n}`],
+    entered: ["entered"],
+    hidden: ["hidden"],
+    wrapper: ["wrapper", `${n}`],
+    wrapperInner: ["wrapperInner", `${n}`]
+  };
+  return re(d, de, s);
+}, he = b("div", {
+  name: "MuiCollapse",
+  slot: "Root",
+  overridesResolver: (o, n) => {
+    const {
+      ownerState: s
+    } = o;
+    return [n.root, n[s.orientation], s.state === "entered" && n.entered, s.state === "exited" && !s.in && s.collapsedSize === "0px" && n.hidden];
+  }
+})(({
+  theme: o,
+  ownerState: n
+}) => r({
+  height: 0,
+  overflow: "hidden",
+  transition: o.transitions.create("height")
+}, n.orientation === "horizontal" && {
+  height: "auto",
+  width: 0,
+  transition: o.transitions.create("width")
+}, n.state === "entered" && r({
+  height: "auto",
+  overflow: "visible"
+}, n.orientation === "horizontal" && {
+  width: "auto"
+}), n.state === "exited" && !n.in && n.collapsedSize === "0px" && {
+  visibility: "hidden"
+})), ge = b("div", {
+  name: "MuiCollapse",
+  slot: "Wrapper",
+  overridesResolver: (o, n) => n.wrapper
+})(({
+  ownerState: o
+}) => r({
+  // Hack to get children with a negative margin to not falsify the height computation.
+  display: "flex",
+  width: "100%"
+}, o.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), xe = b("div", {
+  name: "MuiCollapse",
+  slot: "WrapperInner",
+  overridesResolver: (o, n) => n.wrapperInner
+})(({
+  ownerState: o
+}) => r({
+  width: "100%"
+}, o.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), S = /* @__PURE__ */ u.forwardRef(function(n, s) {
+  const d = oe({
+    props: n,
+    name: "MuiCollapse"
+  }), {
+    addEndListener: j,
+    children: A,
+    className: U,
+    collapsedSize: x = "0px",
+    component: V,
+    easing: $,
+    in: D,
+    onEnter: O,
+    onEntered: N,
+    onEntering: W,
+    onExit: P,
+    onExited: k,
+    onExiting: I,
+    orientation: L = "vertical",
+    style: z,
+    timeout: l = ae.standard,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: q = le
+  } = d, B = te(d, fe), E = r({}, d, {
+    orientation: L,
+    collapsedSize: x
+  }), f = me(E), M = pe(), F = u.useRef(), p = u.useRef(null), v = u.useRef(), y = typeof x == "number" ? `${x}px` : x, m = L === "horizontal", h = m ? "width" : "height";
+  u.useEffect(() => () => {
+    clearTimeout(F.current);
+  }, []);
+  const w = u.useRef(null), G = ce(s, w), c = (t) => (i) => {
+    if (t) {
+      const a = w.current;
+      i === void 0 ? t(a) : t(a, i);
+    }
+  }, R = () => p.current ? p.current[m ? "clientWidth" : "clientHeight"] : 0, J = c((t, i) => {
+    p.current && m && (p.current.style.position = "absolute"), t.style[h] = y, O && O(t, i);
+  }), K = c((t, i) => {
+    const a = R();
+    p.current && m && (p.current.style.position = "");
+    const {
+      duration: g,
+      easing: T
+    } = _({
+      style: z,
+      timeout: l,
+      easing: $
+    }, {
+      mode: "enter"
+    });
+    if (l === "auto") {
+      const H = M.transitions.getAutoHeightDuration(a);
+      t.style.transitionDuration = `${H}ms`, v.current = H;
+    } else
+      t.style.transitionDuration = typeof g == "string" ? g : `${g}ms`;
+    t.style[h] = `${a}px`, t.style.transitionTimingFunction = T, W && W(t, i);
+  }), Q = c((t, i) => {
+    t.style[h] = "auto", N && N(t, i);
+  }), X = c((t) => {
+    t.style[h] = `${R()}px`, P && P(t);
+  }), Y = c(k), Z = c((t) => {
+    const i = R(), {
+      duration: a,
+      easing: g
+    } = _({
+      style: z,
+      timeout: l,
+      easing: $
+    }, {
+      mode: "exit"
+    });
+    if (l === "auto") {
+      const T = M.transitions.getAutoHeightDuration(i);
+      t.style.transitionDuration = `${T}ms`, v.current = T;
+    } else
+      t.style.transitionDuration = typeof a == "string" ? a : `${a}ms`;
+    t.style[h] = y, t.style.transitionTimingFunction = g, I && I(t);
+  }), ee = (t) => {
+    l === "auto" && (F.current = setTimeout(t, v.current || 0)), j && j(w.current, t);
+  };
+  return /* @__PURE__ */ C.jsx(q, r({
+    in: D,
+    onEnter: J,
+    onEntered: Q,
+    onEntering: K,
+    onExit: X,
+    onExited: Y,
+    onExiting: Z,
+    addEndListener: ee,
+    nodeRef: w,
+    timeout: l === "auto" ? null : l
+  }, B, {
+    children: (t, i) => /* @__PURE__ */ C.jsx(he, r({
+      as: V,
+      className: ie(f.root, U, {
+        entered: f.entered,
+        exited: !D && y === "0px" && f.hidden
+      }[t]),
+      style: r({
+        [m ? "minWidth" : "minHeight"]: y
+      }, z),
+      ownerState: r({}, E, {
+        state: t
+      }),
+      ref: G
+    }, i, {
+      children: /* @__PURE__ */ C.jsx(ge, {
+        ownerState: r({}, E, {
+          state: t
+        }),
+        className: f.wrapper,
+        ref: p,
+        children: /* @__PURE__ */ C.jsx(xe, {
+          ownerState: r({}, E, {
+            state: t
+          }),
+          className: f.wrapperInner,
+          children: A
+        })
+      })
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (S.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: e.func,
+  /**
+   * The content node to be collapsed.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The width (horizontal) or height (vertical) of the container when collapsed.
+   * @default '0px'
+   */
+  collapsedSize: e.oneOfType([e.number, e.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: ue,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: e.oneOfType([e.shape({
+    enter: e.string,
+    exit: e.string
+  }), e.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: e.bool,
+  /**
+   * @ignore
+   */
+  onEnter: e.func,
+  /**
+   * @ignore
+   */
+  onEntered: e.func,
+  /**
+   * @ignore
+   */
+  onEntering: e.func,
+  /**
+   * @ignore
+   */
+  onExit: e.func,
+  /**
+   * @ignore
+   */
+  onExited: e.func,
+  /**
+   * @ignore
+   */
+  onExiting: e.func,
+  /**
+   * The transition orientation.
+   * @default 'vertical'
+   */
+  orientation: e.oneOf(["horizontal", "vertical"]),
+  /**
+   * @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 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 duration.standard
+   */
+  timeout: e.oneOfType([e.oneOf(["auto"]), e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })])
+});
+S.muiSupportAuto = !0;
+const be = S;
+export {
+  be as C
+};

package/dist/CopyToClipboard/index.d.ts

@@ -0,0 +1,3 @@
+export { default as KdpaCopyToClipboard } from "./KdpaCopyToClipboard";
+export type { CopyToClipboardComponentProps } from "./KdpaCopyToClipboard";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/CopyToClipboard/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACvE,YAAY,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC"}