@hybridcore/ui 1.1.2 → 1.2.0

package/dist/Collapse-9egEADkh.js

@@ -0,0 +1,296 @@
+import { a as r, _ as ee } from "./extends-C3382pL0.js";
+import * as z from "react";
+import { g as te, u as ne, c as oe, a as ie } from "./chainPropTypes-BmidnkZm.js";
+import { P as e } from "./createTheme-oOCi1S_n.js";
+import { g as re, s as b, b as se } from "./styled-Wx2vv4j8.js";
+import { T as ae, g as A } from "./utils-BEaBPoDF.js";
+import { u as le } from "./useTheme-CD5DEi5n.js";
+import { jsx as C } from "react/jsx-runtime";
+import { u as pe, a as ce, e as de } from "./ButtonBase-C7CHOX3y.js";
+function ue(o) {
+  return re("MuiCollapse", o);
+}
+te("MuiCollapse", ["root", "horizontal", "vertical", "entered", "hidden", "wrapper", "wrapperInner"]);
+const he = ["addEndListener", "children", "className", "collapsedSize", "component", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "orientation", "style", "timeout", "TransitionComponent"], fe = (o) => {
+  const {
+    orientation: n,
+    classes: s
+  } = o, d = {
+    root: ["root", `${n}`],
+    entered: ["entered"],
+    hidden: ["hidden"],
+    wrapper: ["wrapper", `${n}`],
+    wrapperInner: ["wrapperInner", `${n}`]
+  };
+  return ie(d, ue, s);
+}, me = 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%"
+})), Ee = b("div", {
+  name: "MuiCollapse",
+  slot: "WrapperInner",
+  overridesResolver: (o, n) => n.wrapperInner
+})(({
+  ownerState: o
+}) => r({
+  width: "100%"
+}, o.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), F = /* @__PURE__ */ z.forwardRef(function(n, s) {
+  const d = ne({
+    props: n,
+    name: "MuiCollapse"
+  }), {
+    addEndListener: S,
+    children: H,
+    className: _,
+    collapsedSize: g = "0px",
+    component: U,
+    easing: D,
+    in: $,
+    onEnter: O,
+    onEntered: N,
+    onEntering: W,
+    onExit: L,
+    onExited: V,
+    onExiting: P,
+    orientation: j = "vertical",
+    style: T,
+    timeout: l = se.standard,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: k = ae
+  } = d, q = ee(d, he), E = r({}, d, {
+    orientation: j,
+    collapsedSize: g
+  }), u = fe(E), I = le(), B = pe(), p = z.useRef(null), v = z.useRef(), x = typeof g == "number" ? `${g}px` : g, h = j === "horizontal", f = h ? "width" : "height", y = z.useRef(null), G = ce(s, y), c = (t) => (i) => {
+    if (t) {
+      const a = y.current;
+      i === void 0 ? t(a) : t(a, i);
+    }
+  }, R = () => p.current ? p.current[h ? "clientWidth" : "clientHeight"] : 0, J = c((t, i) => {
+    p.current && h && (p.current.style.position = "absolute"), t.style[f] = x, O && O(t, i);
+  }), K = c((t, i) => {
+    const a = R();
+    p.current && h && (p.current.style.position = "");
+    const {
+      duration: m,
+      easing: w
+    } = A({
+      style: T,
+      timeout: l,
+      easing: D
+    }, {
+      mode: "enter"
+    });
+    if (l === "auto") {
+      const M = I.transitions.getAutoHeightDuration(a);
+      t.style.transitionDuration = `${M}ms`, v.current = M;
+    } else
+      t.style.transitionDuration = typeof m == "string" ? m : `${m}ms`;
+    t.style[f] = `${a}px`, t.style.transitionTimingFunction = w, W && W(t, i);
+  }), Q = c((t, i) => {
+    t.style[f] = "auto", N && N(t, i);
+  }), X = c((t) => {
+    t.style[f] = `${R()}px`, L && L(t);
+  }), Y = c(V), Z = c((t) => {
+    const i = R(), {
+      duration: a,
+      easing: m
+    } = A({
+      style: T,
+      timeout: l,
+      easing: D
+    }, {
+      mode: "exit"
+    });
+    if (l === "auto") {
+      const w = I.transitions.getAutoHeightDuration(i);
+      t.style.transitionDuration = `${w}ms`, v.current = w;
+    } else
+      t.style.transitionDuration = typeof a == "string" ? a : `${a}ms`;
+    t.style[f] = x, t.style.transitionTimingFunction = m, P && P(t);
+  });
+  return /* @__PURE__ */ C(k, r({
+    in: $,
+    onEnter: J,
+    onEntered: Q,
+    onEntering: K,
+    onExit: X,
+    onExited: Y,
+    onExiting: Z,
+    addEndListener: (t) => {
+      l === "auto" && B.start(v.current || 0, t), S && S(y.current, t);
+    },
+    nodeRef: y,
+    timeout: l === "auto" ? null : l
+  }, q, {
+    children: (t, i) => /* @__PURE__ */ C(me, r({
+      as: U,
+      className: oe(u.root, _, {
+        entered: u.entered,
+        exited: !$ && x === "0px" && u.hidden
+      }[t]),
+      style: r({
+        [h ? "minWidth" : "minHeight"]: x
+      }, T),
+      ref: G
+    }, i, {
+      // `ownerState` is set after `childProps` to override any existing `ownerState` property in `childProps`
+      // that might have been forwarded from the Transition component.
+      ownerState: r({}, E, {
+        state: t
+      }),
+      children: /* @__PURE__ */ C(ge, {
+        ownerState: r({}, E, {
+          state: t
+        }),
+        className: u.wrapper,
+        ref: p,
+        children: /* @__PURE__ */ C(Ee, {
+          ownerState: r({}, E, {
+            state: t
+          }),
+          className: u.wrapperInner,
+          children: H
+        })
+      })
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (F.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm 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: de,
+  /**
+   * 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
+  })])
+});
+F.muiSupportAuto = !0;
+export {
+  F as C
+};