@pismo/marola 2.1.64 → 2.1.65

package/dist/Button-CJaBSdv1.js

@@ -0,0 +1,135 @@
+import * as a from "react";
+import { g as C, a as R, b as T, c as B, d as O, P as o } from "./ClassNameConfigurator-CVRWfyIa.js";
+import { jsx as x } from "react/jsx-runtime";
+import { u as F } from "./useButton-C2E_LFJp.js";
+const b = "Button";
+function S(s) {
+  return C(b, s);
+}
+R(b, ["root", "active", "disabled", "focusVisible"]);
+const U = (s) => {
+  const {
+    active: e,
+    disabled: r,
+    focusVisible: n
+  } = s;
+  return B({
+    root: ["root", r && "disabled", n && "focusVisible", e && "active"]
+  }, O(S));
+}, w = /* @__PURE__ */ a.forwardRef(function(e, r) {
+  const {
+    action: n,
+    children: c,
+    disabled: D,
+    focusableWhenDisabled: u = !1,
+    onFocusVisible: j,
+    slotProps: m = {},
+    slots: i = {},
+    rootElementName: h = "button",
+    ...t
+  } = e, P = a.useRef(null);
+  let l = h;
+  typeof i.root == "string" ? l = i.root : (t.href || t.to) && (l = "a");
+  const {
+    active: N,
+    focusVisible: g,
+    setFocusVisible: f,
+    getRootProps: y
+  } = F({
+    ...e,
+    focusableWhenDisabled: u,
+    rootElementName: l
+  });
+  a.useImperativeHandle(n, () => ({
+    focusVisible: () => {
+      f(!0), P.current.focus();
+    }
+  }), [f]);
+  const p = {
+    ...e,
+    active: N,
+    focusableWhenDisabled: u,
+    focusVisible: g
+  }, V = U(p), E = t.href || t.to ? "a" : "button", d = i.root ?? E, v = T({
+    elementType: d,
+    getSlotProps: y,
+    externalForwardedProps: t,
+    externalSlotProps: m.root,
+    additionalProps: {
+      ref: r
+    },
+    ownerState: p,
+    className: V.root
+  });
+  return /* @__PURE__ */ x(d, {
+    ...v,
+    children: c
+  });
+});
+process.env.NODE_ENV !== "production" && (w.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * A ref for imperative actions. It currently only supports `focusVisible()` action.
+   */
+  action: o.oneOfType([o.func, o.shape({
+    current: o.shape({
+      focusVisible: o.func.isRequired
+    })
+  })]),
+  /**
+   * @ignore
+   */
+  children: o.node,
+  /**
+   * @ignore
+   */
+  className: o.string,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: o.bool,
+  /**
+   * If `true`, allows a disabled button to receive focus.
+   * @default false
+   */
+  focusableWhenDisabled: o.bool,
+  /**
+   * @ignore
+   */
+  href: o.string,
+  /**
+   * @ignore
+   */
+  onFocusVisible: o.func,
+  /**
+   * The HTML element that is ultimately rendered, for example 'button' or 'a'
+   * @default 'button'
+   */
+  rootElementName: o.string,
+  /**
+   * The props used for each slot inside the Button.
+   * @default {}
+   */
+  slotProps: o.shape({
+    root: o.oneOfType([o.func, o.object])
+  }),
+  /**
+   * The components used for each slot inside the Button.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: o.shape({
+    root: o.elementType
+  }),
+  /**
+   * @ignore
+   */
+  to: o.string
+});
+export {
+  w as B
+};