@pismo/marola 2.1.26 → 2.1.27

package/dist/RadioOption-DCTydlPv.js

@@ -0,0 +1,720 @@
+import { jsx as p, jsxs as A } from "react/jsx-runtime";
+import { c as J } from "./clsx-OuTLNxxd.js";
+import "./utils/iconsList.js";
+import { Typography as Q } from "./components/Typography/Typography.js";
+import * as s from "react";
+import "./components/Input/Input.js";
+import "./components/Avatar/Avatar.js";
+import "./components/Button/Button.js";
+import "./Toggle-SlvGYQKW.js";
+import "./components/Dialog/Dialog.js";
+import "./components/DatePicker/DatePicker.js";
+import { r as X } from "./index-1UpBa69h.js";
+import "./components/Draggable/useDraggable.js";
+import "./components/IconButton/IconButton.js";
+import "./components/InputSearch/InputSearch.js";
+import "./components/Select/Select.js";
+import "./components/Popover/Popover.js";
+import "./components/Table/Table.js";
+import "./components/Tabs/Tabs.js";
+import "./Group-DJz1rK2n.js";
+import "./contexts/SnackbarProvider/SnackbarProvider.js";
+import { P as a } from "./useSlotProps-CYHDC4TN.js";
+import './assets/RadioOption.css';const P = () => {
+};
+function Z(e, t) {
+  let n = {};
+  return Object.entries(e).forEach(([o, r]) => {
+    if (t != null && t.hasOwnProperty(o)) {
+      const d = t[o](r);
+      d != null && (n = {
+        ...n,
+        ...d
+      });
+      return;
+    }
+    r === !0 ? n[`data-${o.toLowerCase()}`] = "" : r && (n[`data-${o.toLowerCase()}`] = r.toString());
+  }), n;
+}
+function ee(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function w(e, ...t) {
+  let n = t[0];
+  for (let o = 1; o < t.length; o += 1)
+    n = F(n, t[o]);
+  return F(e, n);
+}
+function F(e, t) {
+  return e ? Object.entries(e).reduce((n, [o, r]) => (// This approach is more efficient than using a regex.
+  o[0] === "o" && o[1] === "n" && o.charCodeAt(2) >= 65 && o.charCodeAt(2) <= 90 && typeof r == "function" ? n[o] = (d) => {
+    let i = !1;
+    const u = r, l = t[o], m = d;
+    m.preventBaseUIHandler = () => {
+      i = !0;
+    };
+    const f = u(m);
+    return i || l == null || l(m), f;
+  } : o === "style" ? (r || t.style) && (n[o] = {
+    ...t.style,
+    ...r || {}
+  }) : o === "className" ? r ? t.className ? n[o] = r + " " + t.className : n[o] = r : n[o] = t.className : n[o] = r, n), {
+    ...t
+  }) : t;
+}
+function te(e, t, n) {
+  return typeof e == "function" ? e(t, n) : /* @__PURE__ */ s.cloneElement(e, {
+    ...w(e.props, t),
+    ref: t.ref
+  });
+}
+function M(...e) {
+  return s.useMemo(() => e.every((t) => t == null) ? null : (t) => {
+    e.forEach((n) => {
+      ne(n, t);
+    });
+  }, e);
+}
+function ne(e, t) {
+  typeof e == "function" ? e(t) : e && (e.current = t);
+}
+const oe = parseInt(s.version, 10);
+function re(e) {
+  return oe >= e;
+}
+function se(e, ...t) {
+  let n;
+  return typeof e != "function" ? n = re(19) ? e.props.ref : e.ref : n = null, M(n, ...t);
+}
+const ie = {
+  button: (e) => /* @__PURE__ */ p("button", {
+    type: "button",
+    ...e
+  }),
+  div: (e) => /* @__PURE__ */ p("div", {
+    ...e
+  }),
+  h2: (e) => /* @__PURE__ */ p("h2", {
+    ...e
+  }),
+  h3: (e) => /* @__PURE__ */ p("h3", {
+    ...e
+  }),
+  output: (e) => /* @__PURE__ */ p("output", {
+    ...e
+  }),
+  p: (e) => /* @__PURE__ */ p("p", {
+    ...e
+  }),
+  span: (e) => /* @__PURE__ */ p("span", {
+    ...e
+  }),
+  a: (e) => /* @__PURE__ */ p("a", {
+    ...e
+  }),
+  label: (e) => /* @__PURE__ */ p("label", {
+    ...e
+  }),
+  input: (e) => /* @__PURE__ */ p("input", {
+    ...e
+  }),
+  fieldset: (e) => /* @__PURE__ */ p("fieldset", {
+    ...e
+  }),
+  form: (e) => /* @__PURE__ */ p("form", {
+    ...e
+  }),
+  img: (e) => /* @__PURE__ */ p("img", {
+    alt: "",
+    ...e
+  })
+};
+function D(e) {
+  const {
+    render: t,
+    className: n,
+    state: o,
+    ref: r,
+    propGetter: d = (C) => C,
+    extraProps: i,
+    customStyleHookMapping: u
+  } = e, l = ee(n, o), f = {
+    ...s.useMemo(() => Z(o, u), [o, u]),
+    ...i
+  };
+  let h;
+  typeof t == "string" ? h = ie[t] : h = t;
+  const c = d(f), R = {
+    ...c,
+    ref: se(h, r, c.ref)
+  };
+  return l !== void 0 && (R.className = l), {
+    renderElement: () => te(h, R, o)
+  };
+}
+const E = typeof window < "u" ? s.useLayoutEffect : s.useEffect, q = /* @__PURE__ */ s.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  map: /* @__PURE__ */ new Map(),
+  elementsRef: {
+    current: []
+  }
+});
+process.env.NODE_ENV !== "production" && (q.displayName = "CompositeListContext");
+function ae() {
+  return s.useContext(q);
+}
+function V(e) {
+  const t = s.useRef(e);
+  return E(() => {
+    t.current = e;
+  }), s.useCallback((...n) => {
+    var o;
+    return (o = t.current) == null ? void 0 : o.call(t, ...n);
+  }, []);
+}
+function de(e, t = !1) {
+  const [n, o] = s.useState(), [r, d] = s.useState(e);
+  return e && !r && (d(!0), n !== "starting" && !t && o("starting")), !e && r && n !== "ending" && o("ending"), !e && !r && n === "ending" && o(void 0), E(() => {
+    if (!e)
+      return;
+    t && o("starting");
+    const i = requestAnimationFrame(() => {
+      o(void 0);
+    });
+    return () => {
+      cancelAnimationFrame(i);
+    };
+  }, [e, t]), s.useMemo(() => ({
+    mounted: r,
+    setMounted: d,
+    transitionStatus: n
+  }), [r, n]);
+}
+function le(e = {}) {
+  const {
+    label: t,
+    metadata: n
+  } = e, {
+    register: o,
+    unregister: r,
+    map: d,
+    elementsRef: i,
+    labelsRef: u
+  } = ae(), [l, m] = s.useState(null), f = s.useRef(null), h = s.useCallback((c) => {
+    if (f.current = c, l !== null && (i.current[l] = c, u)) {
+      const R = t !== void 0;
+      u.current[l] = R ? t : (c == null ? void 0 : c.textContent) ?? null;
+    }
+  }, [l, i, u, t]);
+  return E(() => {
+    const c = f.current;
+    if (c)
+      return o(c, n), () => {
+        r(c);
+      };
+  }, [o, r, n]), E(() => {
+    var R;
+    const c = f.current ? (R = d.get(f.current)) == null ? void 0 : R.index : null;
+    c != null && m(c);
+  }, [d]), s.useMemo(() => ({
+    ref: h,
+    index: l ?? -1
+  }), [l, h]);
+}
+const ue = {
+  "data-starting-style": ""
+}, ce = {
+  "data-ending-style": ""
+}, fe = {
+  transitionStatus(e) {
+    return e === "starting" ? ue : e === "ending" ? ce : null;
+  }
+};
+function pe(e, t = !1) {
+  const n = s.useRef(-1), o = s.useRef(-1), r = V(() => {
+    cancelAnimationFrame(n.current), clearTimeout(o.current);
+  });
+  return s.useEffect(() => r, [r]), V((d) => {
+    r();
+    const i = e.current;
+    i && (typeof i.getAnimations != "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED ? d() : n.current = requestAnimationFrame(() => {
+      function u() {
+        i && Promise.allSettled(i.getAnimations().map((l) => l.finished)).then(() => {
+          X.flushSync(d);
+        });
+      }
+      t ? o.current = window.setTimeout(u) : u();
+    }));
+  });
+}
+const me = a.oneOfType([a.func, a.object]);
+function he(e) {
+  const t = s.useRef(e);
+  return E(() => {
+    t.current = e;
+  }), t;
+}
+function Re(e) {
+  const {
+    open: t,
+    ref: n,
+    onComplete: o
+  } = e, r = he(t), d = V(o), i = pe(n, t);
+  E(() => {
+    i(() => {
+      t === r.current && d();
+    });
+  }, [t, d, i, r]);
+}
+let L = /* @__PURE__ */ function(e) {
+  return e.disabled = "data-disabled", e.valid = "data-valid", e.invalid = "data-invalid", e.touched = "data-touched", e.dirty = "data-dirty", e.filled = "data-filled", e.focused = "data-focused", e;
+}({});
+const ye = {
+  badInput: !1,
+  customError: !1,
+  patternMismatch: !1,
+  rangeOverflow: !1,
+  rangeUnderflow: !1,
+  stepMismatch: !1,
+  tooLong: !1,
+  tooShort: !1,
+  typeMismatch: !1,
+  valid: null,
+  valueMissing: !1
+}, ge = {
+  valid(e) {
+    return e === null ? null : e ? {
+      [L.valid]: ""
+    } : {
+      [L.invalid]: ""
+    };
+  }
+}, _ = () => {
+}, H = /* @__PURE__ */ s.createContext({
+  invalid: void 0,
+  controlId: void 0,
+  setControlId: _,
+  labelId: void 0,
+  setLabelId: _,
+  messageIds: [],
+  setMessageIds: _,
+  name: void 0,
+  validityData: {
+    state: ye,
+    errors: [],
+    error: "",
+    value: "",
+    initialValue: null
+  },
+  setValidityData: _,
+  disabled: void 0,
+  touched: !1,
+  setTouched: _,
+  dirty: !1,
+  setDirty: _,
+  filled: !1,
+  setFilled: _,
+  focused: !1,
+  setFocused: _,
+  validate: () => null,
+  validationMode: "onBlur",
+  validationDebounceTime: 0,
+  state: {
+    disabled: !1,
+    valid: null,
+    touched: !1,
+    dirty: !1,
+    filled: !1,
+    focused: !1
+  },
+  markedDirtyRef: {
+    current: !1
+  }
+});
+process.env.NODE_ENV !== "production" && (H.displayName = "FieldRootContext");
+function G(e = !0) {
+  const t = s.useContext(H);
+  if (t.setControlId === _ && !e)
+    throw new Error("Base UI: FieldRootContext is missing. Field parts must be placed within <Field.Root>.");
+  return t;
+}
+const be = {
+  clip: "rect(0 0 0 0)",
+  overflow: "hidden",
+  whiteSpace: "nowrap",
+  position: "fixed",
+  top: 0,
+  left: 0,
+  border: 0,
+  padding: 0,
+  width: 1,
+  height: 1,
+  margin: -1
+}, U = /* @__PURE__ */ s.createContext({
+  disabled: void 0,
+  readOnly: void 0,
+  required: void 0,
+  checkedValue: "",
+  setCheckedValue: P,
+  onValueChange: P,
+  touched: !1,
+  setTouched: P
+});
+process.env.NODE_ENV !== "production" && (U.displayName = "RadioGroupContext");
+function B() {
+  return s.useContext(U);
+}
+function xe(e) {
+  const {
+    disabled: t,
+    readOnly: n,
+    value: o,
+    required: r
+  } = e, {
+    checkedValue: d,
+    setCheckedValue: i,
+    onValueChange: u,
+    touched: l,
+    setTouched: m,
+    fieldControlValidation: f
+  } = B(), {
+    setDirty: h,
+    validityData: c,
+    setTouched: R,
+    setFilled: x,
+    validationMode: C
+  } = G(), g = d === o, v = s.useRef(null);
+  E(() => {
+    var b;
+    (b = v.current) != null && b.checked && x(!0);
+  }, [x]);
+  const I = s.useCallback((b) => w(f ? f.getValidationProps(b) : b, {
+    role: "radio",
+    type: "button",
+    "aria-checked": g,
+    "aria-required": r || void 0,
+    "aria-disabled": t || void 0,
+    "aria-readonly": n || void 0,
+    disabled: t,
+    onKeyDown(y) {
+      y.key === "Enter" && y.preventDefault();
+    },
+    onClick(y) {
+      var N;
+      y.defaultPrevented || t || n || (y.preventDefault(), (N = v.current) == null || N.click());
+    },
+    onFocus(y) {
+      var N;
+      y.defaultPrevented || t || n || !l || ((N = v.current) == null || N.click(), m(!1));
+    }
+  }), [f, g, r, t, n, l, m]), T = s.useCallback((b) => w(b, {
+    type: "radio",
+    ref: v,
+    tabIndex: -1,
+    style: be,
+    "aria-hidden": !0,
+    disabled: t,
+    checked: g,
+    required: r,
+    readOnly: n,
+    onChange(y) {
+      y.nativeEvent.defaultPrevented || t || n || o == null || (R(!0), h(o !== c.initialValue), i(o), x(!0), u == null || u(o, y.nativeEvent), C === "onChange" && (f == null || f.commitValidation(o)));
+    }
+  }), [t, g, r, n, o, R, h, c.initialValue, i, x, u, C, f]);
+  return s.useMemo(() => ({
+    checked: g,
+    getRootProps: I,
+    getInputProps: T
+  }), [g, I, T]);
+}
+const S = /* @__PURE__ */ s.createContext(void 0);
+process.env.NODE_ENV !== "production" && (S.displayName = "RadioRootContext");
+function Ce() {
+  const e = s.useContext(S);
+  if (e === void 0)
+    throw new Error("Base UI: RadioRootContext is missing. Radio parts must be placed within <Radio.Root>.");
+  return e;
+}
+const j = /* @__PURE__ */ s.createContext(void 0);
+process.env.NODE_ENV !== "production" && (j.displayName = "CompositeRootContext");
+function K() {
+  const e = s.useContext(j);
+  if (e === void 0)
+    throw new Error("Base UI: CompositeRootContext is missing. Composite parts must be placed within <Composite.Root>.");
+  return e;
+}
+function _e(e = {}) {
+  const {
+    highlightedIndex: t,
+    onHighlightedIndexChange: n
+  } = K(), {
+    ref: o,
+    index: r
+  } = le(e), d = t === r, i = s.useCallback((u = {}) => w(u, {
+    tabIndex: d ? 0 : -1,
+    onFocus() {
+      n(r);
+    }
+  }), [d, r, n]);
+  return s.useMemo(() => ({
+    getItemProps: i,
+    ref: o,
+    index: r
+  }), [i, o, r]);
+}
+function $(e) {
+  const {
+    render: t,
+    className: n,
+    itemRef: o,
+    metadata: r,
+    ...d
+  } = e, {
+    highlightedIndex: i
+  } = K(), {
+    getItemProps: u,
+    ref: l,
+    index: m
+  } = _e({
+    metadata: r
+  }), f = s.useMemo(() => ({
+    highlighted: m === i
+  }), [m, i]), h = M(o, l), {
+    renderElement: c
+  } = D({
+    propGetter: u,
+    ref: h,
+    render: t ?? "div",
+    state: f,
+    className: n,
+    extraProps: d
+  });
+  return c();
+}
+process.env.NODE_ENV !== "production" && ($.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  children: a.node,
+  /**
+   * CSS class applied to the element, or a function that
+   * returns a class based on the component’s state.
+   */
+  className: a.oneOfType([a.func, a.string]),
+  /**
+   * @ignore
+   */
+  itemRef: me,
+  /**
+   * @ignore
+   */
+  metadata: a.any,
+  /**
+   * Allows you to replace the component’s HTML element
+   * with a different tag, or compose it with another component.
+   *
+   * Accepts a `ReactElement` or a function that returns the element to render.
+   */
+  render: a.oneOfType([a.element, a.func])
+});
+const W = {
+  checked(e) {
+    return e ? {
+      "data-checked": ""
+    } : {
+      "data-unchecked": ""
+    };
+  },
+  ...fe,
+  ...ge
+}, Y = /* @__PURE__ */ s.forwardRef(function(t, n) {
+  const {
+    render: o,
+    className: r,
+    disabled: d = !1,
+    readOnly: i = !1,
+    required: u = !1,
+    ...l
+  } = t, {
+    disabled: m,
+    readOnly: f,
+    required: h,
+    setCheckedValue: c
+  } = B(), {
+    state: R,
+    disabled: x
+  } = G(), C = x || m || d, g = f || i, v = h || u, {
+    getRootProps: I,
+    getInputProps: T,
+    checked: b
+  } = xe({
+    ...t,
+    disabled: C,
+    readOnly: g
+  }), y = s.useMemo(() => ({
+    ...R,
+    required: v,
+    disabled: C,
+    readOnly: g,
+    checked: b
+  }), [R, C, g, b, v]), N = s.useMemo(() => y, [y]), {
+    renderElement: k
+  } = D({
+    propGetter: I,
+    render: o ?? "button",
+    ref: n,
+    className: r,
+    state: y,
+    extraProps: l,
+    customStyleHookMapping: W
+  });
+  return /* @__PURE__ */ A(S.Provider, {
+    value: N,
+    children: [c === P ? k() : /* @__PURE__ */ p($, {
+      render: k()
+    }), /* @__PURE__ */ p("input", {
+      ...T()
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (Y.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  children: a.node,
+  /**
+   * CSS class applied to the element, or a function that
+   * returns a class based on the component’s state.
+   */
+  className: a.oneOfType([a.func, a.string]),
+  /**
+   * Whether the component should ignore user interaction.
+   * @default false
+   */
+  disabled: a.bool,
+  /**
+   * Whether the user should be unable to select the radio button.
+   * @default false
+   */
+  readOnly: a.bool,
+  /**
+   * Allows you to replace the component’s HTML element
+   * with a different tag, or compose it with another component.
+   *
+   * Accepts a `ReactElement` or a function that returns the element to render.
+   */
+  render: a.oneOfType([a.element, a.func]),
+  /**
+   * Whether the user must choose a value before submitting a form.
+   * @default false
+   */
+  required: a.bool,
+  /**
+   * The unique identifying value of the radio in a group.
+   */
+  value: a.any.isRequired
+});
+const z = /* @__PURE__ */ s.forwardRef(function(t, n) {
+  const {
+    render: o,
+    className: r,
+    keepMounted: d = !1,
+    ...i
+  } = t, u = Ce(), l = u.checked, {
+    transitionStatus: m,
+    setMounted: f
+  } = de(l), h = s.useMemo(() => ({
+    ...u,
+    transitionStatus: m
+  }), [u, m]), c = s.useRef(null), R = M(n, c), {
+    renderElement: x
+  } = D({
+    render: o ?? "span",
+    ref: R,
+    className: r,
+    state: h,
+    extraProps: i,
+    customStyleHookMapping: W
+  });
+  return Re({
+    open: l,
+    ref: c,
+    onComplete() {
+      l || f(!1);
+    }
+  }), d || l ? x() : null;
+});
+process.env.NODE_ENV !== "production" && (z.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  children: a.node,
+  /**
+   * CSS class applied to the element, or a function that
+   * returns a class based on the component’s state.
+   */
+  className: a.oneOfType([a.func, a.string]),
+  /**
+   * Whether to keep the HTML element in the DOM when the radio button is inactive.
+   * @default false
+   */
+  keepMounted: a.bool,
+  /**
+   * Allows you to replace the component’s HTML element
+   * with a different tag, or compose it with another component.
+   *
+   * Accepts a `ReactElement` or a function that returns the element to render.
+   */
+  render: a.oneOfType([a.element, a.func])
+});
+const ve = "_option_1xyfv_9", Ne = "_radio_1xyfv_1", Ee = "_indicator_1xyfv_43", O = {
+  "radio-label": "_radio-label_1xyfv_1",
+  "radio-label__disabled": "_radio-label__disabled_1xyfv_4",
+  option: ve,
+  radio: Ne,
+  indicator: Ee,
+  "legacy-radio": "_legacy-radio_1xyfv_59",
+  "legacy-radio--label": "_legacy-radio--label_1xyfv_67",
+  "legacy-radio--label__disabled": "_legacy-radio--label__disabled_1xyfv_70",
+  "legacy-radio--input": "_legacy-radio--input_1xyfv_74",
+  "legacy-radio--input__disabled": "_legacy-radio--input__disabled_1xyfv_84",
+  "legacy-radio--disabled": "_legacy-radio--disabled_1xyfv_95"
+}, We = ({ label: e, value: t, disabled: n, "data-testid": o }) => {
+  const r = J(O["radio-label"], n && O["radio-label__disabled"]);
+  return /* @__PURE__ */ A("label", { className: O.option, "data-testid": o, children: [
+    /* @__PURE__ */ p(Y, { disabled: n, value: t, className: O.radio, children: /* @__PURE__ */ p(z, { className: O.indicator }) }),
+    /* @__PURE__ */ p(Q, { color: "var(--colors-neutral-text-color-text)", className: r, variant: "base-lg", children: e })
+  ] });
+};
+export {
+  q as C,
+  ye as D,
+  We as R,
+  G as a,
+  V as b,
+  he as c,
+  M as d,
+  D as e,
+  j as f,
+  U as g,
+  ge as h,
+  w as m,
+  me as r,
+  O as s,
+  E as u
+};

package/dist/components/RadioButton/RadioButton.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="react" />
+export * from './RadioOption';
 export type RadioButtonProps = {
     /** Space separated list of CSS classes to apply */
     className?: string;