@pismo/marola 0.0.1-alpha.5 → 0.0.1-alpha.7

package/dist/components/Toggle/Toggle.js

@@ -0,0 +1,256 @@
+import '../../assets/Toggle.css';
+import { jsxs as I, jsx as O } from "react/jsx-runtime";
+import { c as N } from "../../clsx-DB4S2d7J.js";
+import { a as y, _ as v } from "../../objectWithoutPropertiesLoose-D7Cp0Pg_.js";
+import * as S from "react";
+import { u as U, g as q, a as H, b as V, P as e, c as M, d as A } from "../../index-CqjC7P5Y.js";
+import { u as D } from "../../useControlled-CCMYYdCM.js";
+import { u as L } from "../../useIsFocusVisible-BH4IAdcw.js";
+function W(l) {
+  const {
+    checked: o,
+    defaultChecked: d,
+    disabled: c,
+    onBlur: r,
+    onChange: p,
+    onFocus: g,
+    onFocusVisible: a,
+    readOnly: n,
+    required: P
+  } = l, [u, x] = D({
+    controlled: o,
+    default: !!d,
+    name: "Switch",
+    state: "checked"
+  }), B = (t) => (s) => {
+    var h;
+    s.nativeEvent.defaultPrevented || (x(s.target.checked), p == null || p(s), (h = t.onChange) == null || h.call(t, s));
+  }, {
+    isFocusVisibleRef: m,
+    onBlur: w,
+    onFocus: f,
+    ref: _
+  } = L(), [b, T] = S.useState(!1);
+  c && b && T(!1), S.useEffect(() => {
+    m.current = b;
+  }, [b, m]);
+  const k = S.useRef(null), R = (t) => (s) => {
+    var h;
+    k.current || (k.current = s.currentTarget), f(s), m.current === !0 && (T(!0), a == null || a(s)), g == null || g(s), (h = t.onFocus) == null || h.call(t, s);
+  }, C = (t) => (s) => {
+    var h;
+    w(s), m.current === !1 && T(!1), r == null || r(s), (h = t.onBlur) == null || h.call(t, s);
+  }, F = U(_, k);
+  return {
+    checked: u,
+    disabled: !!c,
+    focusVisible: b,
+    getInputProps: (t = {}) => y({
+      checked: o,
+      defaultChecked: d,
+      disabled: c,
+      readOnly: n,
+      ref: F,
+      required: P,
+      type: "checkbox",
+      role: "switch",
+      "aria-checked": o
+    }, t, {
+      onChange: B(t),
+      onFocus: R(t),
+      onBlur: C(t)
+    }),
+    inputRef: F,
+    readOnly: !!n
+  };
+}
+const $ = "Switch";
+function z(l) {
+  return q($, l);
+}
+H($, ["root", "input", "track", "thumb", "checked", "disabled", "focusVisible", "readOnly"]);
+const G = ["checked", "defaultChecked", "disabled", "onBlur", "onChange", "onFocus", "onFocusVisible", "readOnly", "required", "slotProps", "slots"], J = (l) => {
+  const {
+    checked: o,
+    disabled: d,
+    focusVisible: c,
+    readOnly: r
+  } = l;
+  return M({
+    root: ["root", o && "checked", d && "disabled", c && "focusVisible", r && "readOnly"],
+    thumb: ["thumb"],
+    input: ["input"],
+    track: ["track"]
+  }, A(z));
+}, E = /* @__PURE__ */ S.forwardRef(function(o, d) {
+  var c, r, p, g;
+  const {
+    slotProps: a = {},
+    slots: n = {}
+  } = o, P = v(o, G), {
+    getInputProps: u,
+    checked: x,
+    disabled: B,
+    focusVisible: m,
+    readOnly: w
+  } = W(o), f = y({}, o, {
+    checked: x,
+    disabled: B,
+    focusVisible: m,
+    readOnly: w
+  }), _ = J(f), b = (c = n.root) != null ? c : "span", T = V({
+    elementType: b,
+    externalSlotProps: a.root,
+    externalForwardedProps: P,
+    additionalProps: {
+      ref: d
+    },
+    ownerState: f,
+    className: _.root
+  }), k = (r = n.thumb) != null ? r : "span", R = V({
+    elementType: k,
+    externalSlotProps: a.thumb,
+    ownerState: f,
+    className: _.thumb
+  }), C = (p = n.input) != null ? p : "input", F = V({
+    elementType: C,
+    getSlotProps: u,
+    externalSlotProps: a.input,
+    ownerState: f,
+    className: _.input
+  }), j = n.track === null ? () => null : (g = n.track) != null ? g : "span", t = V({
+    elementType: j,
+    externalSlotProps: a.track,
+    ownerState: f,
+    className: _.track
+  });
+  return /* @__PURE__ */ I(b, y({}, T, {
+    children: [/* @__PURE__ */ O(j, y({}, t)), /* @__PURE__ */ O(k, y({}, R)), /* @__PURE__ */ O(C, y({}, F))]
+  }));
+});
+process.env.NODE_ENV !== "production" && (E.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: e.bool,
+  /**
+   * Class name applied to the root element.
+   */
+  className: e.string,
+  /**
+   * The default checked state. Use when the component is not controlled.
+   */
+  defaultChecked: e.bool,
+  /**
+   * If `true`, the component is disabled.
+   */
+  disabled: e.bool,
+  /**
+   * @ignore
+   */
+  onBlur: e.func,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (string).
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: e.func,
+  /**
+   * @ignore
+   */
+  onFocus: e.func,
+  /**
+   * @ignore
+   */
+  onFocusVisible: e.func,
+  /**
+   * If `true`, the component is read only.
+   */
+  readOnly: e.bool,
+  /**
+   * If `true`, the `input` element is required.
+   */
+  required: e.bool,
+  /**
+   * The props used for each slot inside the Switch.
+   * @default {}
+   */
+  slotProps: e.shape({
+    input: e.oneOfType([e.func, e.object]),
+    root: e.oneOfType([e.func, e.object]),
+    thumb: e.oneOfType([e.func, e.object]),
+    track: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside the Switch.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: e.shape({
+    input: e.elementType,
+    root: e.elementType,
+    thumb: e.elementType,
+    track: e.oneOfType([e.elementType, e.oneOf([null])])
+  })
+});
+const K = "_toggle_r6ihm_1", Q = "_input_r6ihm_15", X = "_thumb_r6ihm_26", Y = "_track_r6ihm_40", Z = "_toggle__label_r6ihm_64", i = {
+  toggle: K,
+  "toggle__toggle-el-wrapper": "_toggle__toggle-el-wrapper_r6ihm_11",
+  input: Q,
+  thumb: X,
+  track: Y,
+  "toggle--focus-visible": "_toggle--focus-visible_r6ihm_50",
+  "toggle--checked": "_toggle--checked_r6ihm_54",
+  toggle__label: Z,
+  "toggle--disabled": "_toggle--disabled_r6ihm_69"
+}, ne = ({
+  onChange: l,
+  label: o,
+  disabled: d,
+  checked: c = !1,
+  autoFocus: r,
+  classNameWrapper: p,
+  classNameLabel: g,
+  classNameInput: a,
+  "data-testid": n
+}) => {
+  const P = (u) => {
+    l == null || l(u);
+  };
+  return /* @__PURE__ */ I("div", { className: N(i.toggle, p), "data-testid": n, children: [
+    /* @__PURE__ */ O(
+      E,
+      {
+        disabled: d,
+        checked: c,
+        autoFocus: r,
+        onChange: P,
+        "aria-label": o,
+        slotProps: {
+          root: (u) => ({
+            className: N(i["toggle__toggle-el-wrapper"], {
+              [i["toggle--disabled"]]: u.disabled,
+              [i["toggle--focus-visible"]]: u.focusVisible,
+              [i["toggle--checked"]]: u.checked
+            })
+          }),
+          input: {
+            className: N(i.input, a)
+          },
+          thumb: { className: i.thumb },
+          track: { className: i.track }
+        }
+      }
+    ),
+    o && /* @__PURE__ */ O("label", { className: N(i.toggle__label, g), children: o })
+  ] });
+};
+export {
+  ne as Toggle
+};

package/dist/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,17 @@
+import { PopupPlacement } from '@mui/base';
+
+type TooltipProps = {
+    children: React.ReactNode;
+    show?: boolean;
+    anchorRef?: HTMLElement | null | undefined;
+    disableHoverListener?: boolean;
+    onClose?: () => void;
+    theme?: 'white' | 'black';
+    padding?: 'small' | 'normal';
+    position?: PopupPlacement;
+    arialRole?: React.AriaRole;
+    className?: string;
+    'data-testid'?: string;
+};
+declare const Tooltip: ({ children, show, anchorRef, onClose, arialRole, position, theme, padding, className, disableHoverListener, ...rest }: TooltipProps) => import("react/jsx-runtime").JSX.Element;
+export { Tooltip };