@clearstory/drywall-react 4.1.2 → 4.1.3

package/dist/Collapse-DSDublNm.js

@@ -0,0 +1,377 @@
+import * as E from "react";
+import { c as U } from "./clsx-OuTLNxxd.js";
+import { P as e } from "./index-CyAhC1RZ.js";
+import { u as ue } from "./useTheme-BRcg8wFh.js";
+import { jsx as T } from "react/jsx-runtime";
+import { s as O } from "./styled-SBTDGe0C.js";
+import { m as de } from "./memoTheme-D_KVIx9Z.js";
+import { j as me } from "./createTheme-C8al1H6l.js";
+import { T as fe, g as V } from "./utils-CAuCuXQr.js";
+import { u as b } from "./useSlot-CoTIuujp.js";
+import { g as he } from "./generateUtilityClasses-E9gROIFd.js";
+import { g as ge } from "./generateUtilityClass-BhfUaMgk.js";
+import { u as ye } from "./DefaultPropsProvider-Hks9kyHW.js";
+import { u as we } from "./useTimeout-DRd4LBXb.js";
+import { u as xe } from "./useForkRef-9kN4DArm.js";
+import { c as Ee } from "./composeClasses-2Ou-RZJr.js";
+import { e as Te } from "./elementTypeAcceptingRef-B2d5_Vhf.js";
+function Se(i) {
+  return ge("MuiCollapse", i);
+}
+const _e = he("MuiCollapse", ["root", "horizontal", "vertical", "entered", "hidden", "wrapper", "wrapperInner"]), Ce = (i) => {
+  const {
+    orientation: n,
+    classes: s
+  } = i, h = {
+    root: ["root", `${n}`],
+    entered: ["entered"],
+    hidden: ["hidden"],
+    wrapper: ["wrapper", `${n}`],
+    wrapperInner: ["wrapperInner", `${n}`]
+  };
+  return Ee(h, Se, s);
+}, ze = O("div", {
+  name: "MuiCollapse",
+  slot: "Root",
+  overridesResolver: (i, n) => {
+    const {
+      ownerState: s
+    } = i;
+    return [n.root, n[s.orientation], s.state === "entered" && n.entered, s.state === "exited" && !s.in && s.collapsedSize === "0px" && n.hidden];
+  }
+})(de(({
+  theme: i
+}) => ({
+  height: 0,
+  overflow: "hidden",
+  transition: i.transitions.create("height"),
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      height: "auto",
+      width: 0,
+      transition: i.transitions.create("width")
+    }
+  }, {
+    props: {
+      state: "entered"
+    },
+    style: {
+      height: "auto",
+      overflow: "visible"
+    }
+  }, {
+    props: {
+      state: "entered",
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto"
+    }
+  }, {
+    props: ({
+      ownerState: n
+    }) => n.state === "exited" && !n.in && n.collapsedSize === "0px",
+    style: {
+      visibility: "hidden"
+    }
+  }]
+}))), ve = O("div", {
+  name: "MuiCollapse",
+  slot: "Wrapper"
+})({
+  // Hack to get children with a negative margin to not falsify the height computation.
+  display: "flex",
+  width: "100%",
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto",
+      height: "100%"
+    }
+  }]
+}), be = O("div", {
+  name: "MuiCollapse",
+  slot: "WrapperInner"
+})({
+  width: "100%",
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto",
+      height: "100%"
+    }
+  }]
+}), R = /* @__PURE__ */ E.forwardRef(function(n, s) {
+  const h = ye({
+    props: n,
+    name: "MuiCollapse"
+  }), {
+    addEndListener: P,
+    children: _,
+    className: k,
+    collapsedSize: g = "0px",
+    component: q,
+    easing: D,
+    in: I,
+    onEnter: $,
+    onEntered: j,
+    onEntering: N,
+    onExit: W,
+    onExited: B,
+    onExiting: F,
+    orientation: M = "vertical",
+    slots: G = {},
+    slotProps: J = {},
+    style: S,
+    timeout: p = me.standard,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: K = fe,
+    ...Q
+  } = h, u = {
+    ...h,
+    orientation: M,
+    collapsedSize: g
+  }, d = Ce(u), H = ue(), X = we(), l = E.useRef(null), C = E.useRef(), y = typeof g == "number" ? `${g}px` : g, m = M === "horizontal", f = m ? "width" : "height", w = E.useRef(null), Y = xe(s, w), c = (t) => (o) => {
+    if (t) {
+      const r = w.current;
+      o === void 0 ? t(r) : t(r, o);
+    }
+  }, z = () => l.current ? l.current[m ? "clientWidth" : "clientHeight"] : 0, Z = c((t, o) => {
+    l.current && m && (l.current.style.position = "absolute"), t.style[f] = y, $ && $(t, o);
+  }), ee = c((t, o) => {
+    const r = z();
+    l.current && m && (l.current.style.position = "");
+    const {
+      duration: a,
+      easing: x
+    } = V({
+      style: S,
+      timeout: p,
+      easing: D
+    }, {
+      mode: "enter"
+    });
+    if (p === "auto") {
+      const L = H.transitions.getAutoHeightDuration(r);
+      t.style.transitionDuration = `${L}ms`, C.current = L;
+    } else
+      t.style.transitionDuration = typeof a == "string" ? a : `${a}ms`;
+    t.style[f] = `${r}px`, t.style.transitionTimingFunction = x, N && N(t, o);
+  }), te = c((t, o) => {
+    t.style[f] = "auto", j && j(t, o);
+  }), ne = c((t) => {
+    t.style[f] = `${z()}px`, W && W(t);
+  }), oe = c(B), re = c((t) => {
+    const o = z(), {
+      duration: r,
+      easing: a
+    } = V({
+      style: S,
+      timeout: p,
+      easing: D
+    }, {
+      mode: "exit"
+    });
+    if (p === "auto") {
+      const x = H.transitions.getAutoHeightDuration(o);
+      t.style.transitionDuration = `${x}ms`, C.current = x;
+    } else
+      t.style.transitionDuration = typeof r == "string" ? r : `${r}ms`;
+    t.style[f] = y, t.style.transitionTimingFunction = a, F && F(t);
+  }), ie = (t) => {
+    p === "auto" && X.start(C.current || 0, t), P && P(w.current, t);
+  }, v = {
+    slots: G,
+    slotProps: J,
+    component: q
+  }, [se, A] = b("root", {
+    ref: Y,
+    className: U(d.root, k),
+    elementType: ze,
+    externalForwardedProps: v,
+    ownerState: u,
+    additionalProps: {
+      style: {
+        [m ? "minWidth" : "minHeight"]: y,
+        ...S
+      }
+    }
+  }), [ae, pe] = b("wrapper", {
+    ref: l,
+    className: d.wrapper,
+    elementType: ve,
+    externalForwardedProps: v,
+    ownerState: u
+  }), [le, ce] = b("wrapperInner", {
+    className: d.wrapperInner,
+    elementType: be,
+    externalForwardedProps: v,
+    ownerState: u
+  });
+  return /* @__PURE__ */ T(K, {
+    in: I,
+    onEnter: Z,
+    onEntered: te,
+    onEntering: ee,
+    onExit: ne,
+    onExited: oe,
+    onExiting: re,
+    addEndListener: ie,
+    nodeRef: w,
+    timeout: p === "auto" ? null : p,
+    ...Q,
+    children: (t, {
+      ownerState: o,
+      ...r
+    }) => {
+      const a = {
+        ...u,
+        state: t
+      };
+      return /* @__PURE__ */ T(se, {
+        ...A,
+        className: U(A.className, {
+          entered: d.entered,
+          exited: !I && y === "0px" && d.hidden
+        }[t]),
+        ownerState: a,
+        ...r,
+        children: /* @__PURE__ */ T(ae, {
+          ...pe,
+          ownerState: a,
+          children: /* @__PURE__ */ T(le, {
+            ...ce,
+            ownerState: a,
+            children: _
+          })
+        })
+      });
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (R.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: Te,
+  /**
+   * 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"]),
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: e.shape({
+    root: e.oneOfType([e.func, e.object]),
+    wrapper: e.oneOfType([e.func, e.object]),
+    wrapperInner: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: e.shape({
+    root: e.elementType,
+    wrapper: e.elementType,
+    wrapperInner: e.elementType
+  }),
+  /**
+   * @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
+  })])
+});
+R && (R.muiSupportAuto = !0);
+export {
+  R as C,
+  _e as c,
+  Se as g
+};

package/dist/{CssBaseline-DRSyTqEj.js → CssBaseline-CqWMIWyO.js}

@@ -1,6 +1,6 @@
 import * as m from "react";
 import { P as p } from "./index-CyAhC1RZ.js";
-import { g as S } from "./index-kh0XXQaW.js";
+import { g as S } from "./index-CSb2qOUI.js";
 import { jsxs as b, jsx as d } from "react/jsx-runtime";
 import { u as y } from "./DefaultPropsProvider-Hks9kyHW.js";
 const n = typeof S({}) == "function", u = (o, e) => ({