@weng-lab/ui-components 3.0.0-beta.0 → 3.0.1

package/dist/ui-components.es314.js

@@ -1,172 +1,524 @@
-import * as p from "react";
-import n from "./ui-components.es89.js";
-import z from "./ui-components.es90.js";
-import { j as A } from "./ui-components.es15.js";
-import { reflow as D, getTransitionProps as x } from "./ui-components.es317.js";
-import V from "./ui-components.es318.js";
-import _ from "./ui-components.es149.js";
-import B from "./ui-components.es187.js";
-import G from "./ui-components.es180.js";
-const H = {
-  entering: {
-    opacity: 1
-  },
-  entered: {
-    opacity: 1
+import * as a from "react";
+import { r as $e } from "./ui-components.es177.js";
+import t from "./ui-components.es89.js";
+import { clsx as Fe } from "./ui-components.es88.js";
+import Ve from "./ui-components.es79.js";
+import { StyledSelectSelect as Ae, StyledSelectIcon as We } from "./ui-components.es316.js";
+import { isFilled as ke } from "./ui-components.es222.js";
+import Te from "./ui-components.es108.js";
+import I, { getSelectUtilityClasses as Ue } from "./ui-components.es317.js";
+import { j as S } from "./ui-components.es15.js";
+import ae from "./ui-components.es169.js";
+import Ke from "./ui-components.es171.js";
+import Be from "./ui-components.es188.js";
+import qe from "./ui-components.es154.js";
+import ze from "./ui-components.es132.js";
+import ue from "./ui-components.es115.js";
+import Le from "./ui-components.es94.js";
+import K from "./ui-components.es34.js";
+import _e from "./ui-components.es140.js";
+var se;
+const He = K(Ae, {
+  name: "MuiSelect",
+  slot: "Select",
+  overridesResolver: (s, r) => {
+    const {
+      ownerState: i
+    } = s;
+    return [
+      // Win specificity over the input base
+      {
+        [`&.${I.select}`]: r.select
+      },
+      {
+        [`&.${I.select}`]: r[i.variant]
+      },
+      {
+        [`&.${I.error}`]: r.error
+      },
+      {
+        [`&.${I.multiple}`]: r.multiple
+      }
+    ];
+  }
+})({
+  // Win specificity over the input base
+  [`&.${I.select}`]: {
+    height: "auto",
+    // Resets for multiple select with chips
+    minHeight: "1.4375em",
+    // Required for select\text-field height consistency
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap",
+    overflow: "hidden"
   }
-}, J = /* @__PURE__ */ p.forwardRef(function(y, g) {
-  const o = z(), h = {
-    enter: o.transitions.duration.enteringScreen,
-    exit: o.transitions.duration.leavingScreen
-  }, {
-    addEndListener: f,
-    appear: R = !0,
-    children: a,
-    easing: m,
-    in: u,
-    onEnter: l,
-    onEntered: T,
-    onEntering: b,
-    onExit: E,
-    onExited: w,
-    onExiting: P,
-    style: d,
-    timeout: c = h,
+}), Ye = K(We, {
+  name: "MuiSelect",
+  slot: "Icon",
+  overridesResolver: (s, r) => {
+    const {
+      ownerState: i
+    } = s;
+    return [r.icon, i.variant && r[`icon${ue(i.variant)}`], i.open && r.iconOpen];
+  }
+})({}), Ge = K("input", {
+  shouldForwardProp: (s) => Te(s) && s !== "classes",
+  name: "MuiSelect",
+  slot: "NativeInput"
+})({
+  bottom: 0,
+  left: 0,
+  position: "absolute",
+  opacity: 0,
+  pointerEvents: "none",
+  width: "100%",
+  boxSizing: "border-box"
+});
+function ie(s, r) {
+  return typeof r == "object" && r !== null ? s === r : String(s) === String(r);
+}
+function Je(s) {
+  return s == null || typeof s == "string" && !s.trim();
+}
+const Qe = (s) => {
+  const {
+    classes: r,
+    variant: i,
+    disabled: x,
+    multiple: j,
+    open: g,
+    error: p
+  } = s, R = {
+    select: ["select", i, x && "disabled", j && "multiple", p && "error"],
+    icon: ["icon", `icon${ue(i)}`, g && "iconOpen", x && "disabled"],
+    nativeInput: ["nativeInput"]
+  };
+  return Le(R, Ue, r);
+}, Xe = /* @__PURE__ */ a.forwardRef(function(r, i) {
+  const {
+    "aria-describedby": x,
+    "aria-label": j,
+    autoFocus: g,
+    autoWidth: p,
+    children: R,
+    className: ce,
+    defaultOpen: B,
+    defaultValue: pe,
+    disabled: C,
+    displayEmpty: de,
+    error: $ = !1,
+    IconComponent: fe,
+    inputRef: me,
+    labelId: w,
+    MenuProps: u = {},
+    multiple: f,
+    name: c,
+    onBlur: q,
+    onChange: P,
+    onClose: z,
+    onFocus: be,
+    // eslint-disable-next-line react/prop-types
+    onKeyDown: ve,
     // eslint-disable-next-line react/prop-types
-    TransitionComponent: j = V,
-    ...v
-  } = y, s = p.useRef(null), L = _(s, B(a), g), r = (e) => (t) => {
+    onMouseDown: ye,
+    onOpen: L,
+    open: _,
+    readOnly: H,
+    renderValue: Y,
+    required: G,
+    SelectDisplayProps: F = {},
+    tabIndex: J,
+    // catching `type` from Input which makes no sense for SelectInput
+    type: Ze,
+    value: he,
+    variant: Se = "standard",
+    ...Q
+  } = r, [o, X] = ae({
+    controlled: he,
+    default: pe,
+    name: "Select"
+  }), [Z, ge] = ae({
+    controlled: _,
+    default: B,
+    name: "Select"
+  }), ee = a.useRef(null), m = a.useRef(null), [E, we] = a.useState(null), {
+    current: V
+  } = a.useRef(_ != null), [Ee, A] = a.useState(), Ie = Ke(i, me), xe = a.useCallback((e) => {
+    m.current = e, e && we(e);
+  }, []), d = E?.parentNode;
+  a.useImperativeHandle(Ie, () => ({
+    focus: () => {
+      m.current.focus();
+    },
+    node: ee.current,
+    value: o
+  }), [o]);
+  const b = E !== null && Z;
+  a.useEffect(() => {
+    if (!b || !d || p || typeof ResizeObserver > "u")
+      return;
+    const e = new ResizeObserver(() => {
+      A(d.clientWidth);
+    });
+    return e.observe(d), () => {
+      e.disconnect();
+    };
+  }, [b, d, p]), a.useEffect(() => {
+    B && Z && E && !V && (A(p ? null : d.clientWidth), m.current.focus());
+  }, [E, p]), a.useEffect(() => {
+    g && m.current.focus();
+  }, [g]), a.useEffect(() => {
+    if (!w)
+      return;
+    const e = Be(m.current).getElementById(w);
     if (e) {
-      const i = s.current;
-      t === void 0 ? e(i) : e(i, t);
+      const n = () => {
+        getSelection().isCollapsed && m.current.focus();
+      };
+      return e.addEventListener("click", n), () => {
+        e.removeEventListener("click", n);
+      };
     }
-  }, F = r(b), O = r((e, t) => {
-    D(e);
-    const i = x({
-      style: d,
-      timeout: c,
-      easing: m
-    }, {
-      mode: "enter"
-    });
-    e.style.webkitTransition = o.transitions.create("opacity", i), e.style.transition = o.transitions.create("opacity", i), l && l(e, t);
-  }), S = r(T), k = r(P), C = r((e) => {
-    const t = x({
-      style: d,
-      timeout: c,
-      easing: m
-    }, {
-      mode: "exit"
-    });
-    e.style.webkitTransition = o.transitions.create("opacity", t), e.style.transition = o.transitions.create("opacity", t), E && E(e);
-  }), N = r(w), q = (e) => {
-    f && f(s.current, e);
+  }, [w]);
+  const O = (e, n) => {
+    e ? L && L(n) : z && z(n), V || (A(p ? null : d.clientWidth), ge(e));
+  }, Ce = (e) => {
+    ye?.(e), e.button === 0 && (e.preventDefault(), m.current.focus(), O(!0, e));
+  }, Pe = (e) => {
+    O(!1, e);
+  }, D = a.Children.toArray(R), Oe = (e) => {
+    const n = D.find((l) => l.props.value === e.target.value);
+    n !== void 0 && (X(n.props.value), P && P(e, n));
+  }, De = (e) => (n) => {
+    let l;
+    if (n.currentTarget.hasAttribute("tabindex")) {
+      if (f) {
+        l = Array.isArray(o) ? o.slice() : [];
+        const h = o.indexOf(e.props.value);
+        h === -1 ? l.push(e.props.value) : l.splice(h, 1);
+      } else
+        l = e.props.value;
+      if (e.props.onClick && e.props.onClick(n), o !== l && (X(l), P)) {
+        const h = n.nativeEvent || n, le = new h.constructor(h.type, h);
+        Object.defineProperty(le, "target", {
+          writable: !0,
+          value: {
+            value: l,
+            name: c
+          }
+        }), P(le, e);
+      }
+      f || O(!1, n);
+    }
+  }, Me = (e) => {
+    H || ([
+      " ",
+      "ArrowUp",
+      "ArrowDown",
+      // The native select doesn't respond to enter on macOS, but it's recommended by
+      // https://www.w3.org/WAI/ARIA/apg/patterns/combobox/examples/combobox-select-only/
+      "Enter"
+    ].includes(e.key) && (e.preventDefault(), O(!0, e)), ve?.(e));
+  }, Ne = (e) => {
+    !b && q && (Object.defineProperty(e, "target", {
+      writable: !0,
+      value: {
+        value: o,
+        name: c
+      }
+    }), q(e));
   };
-  return /* @__PURE__ */ A.jsx(j, {
-    appear: R,
-    in: u,
-    nodeRef: s,
-    onEnter: O,
-    onEntered: S,
-    onEntering: F,
-    onExit: C,
-    onExited: N,
-    onExiting: k,
-    addEndListener: q,
-    timeout: c,
-    ...v,
-    children: (e, {
-      ownerState: t,
-      ...i
-    }) => /* @__PURE__ */ p.cloneElement(a, {
-      style: {
-        opacity: 0,
-        visibility: e === "exited" && !u ? "hidden" : void 0,
-        ...H[e],
-        ...d,
-        ...a.props.style
+  delete Q["aria-invalid"];
+  let v, te;
+  const M = [];
+  let N = !1, W = !1;
+  (ke({
+    value: o
+  }) || de) && (Y ? v = Y(o) : N = !0);
+  const je = D.map((e) => {
+    if (!/* @__PURE__ */ a.isValidElement(e))
+      return null;
+    process.env.NODE_ENV !== "production" && $e.isFragment(e) && console.error(["MUI: The Select component doesn't accept a Fragment as a child.", "Consider providing an array instead."].join(`
+`));
+    let n;
+    if (f) {
+      if (!Array.isArray(o))
+        throw new Error(process.env.NODE_ENV !== "production" ? "MUI: The `value` prop must be an array when using the `Select` component with `multiple`." : qe(2));
+      n = o.some((l) => ie(l, e.props.value)), n && N && M.push(e.props.children);
+    } else
+      n = ie(o, e.props.value), n && N && (te = e.props.children);
+    return n && (W = !0), /* @__PURE__ */ a.cloneElement(e, {
+      "aria-selected": n ? "true" : "false",
+      onClick: De(e),
+      onKeyUp: (l) => {
+        l.key === " " && l.preventDefault(), e.props.onKeyUp && e.props.onKeyUp(l);
       },
-      ref: L,
-      ...i
-    })
+      role: "option",
+      selected: n,
+      value: void 0,
+      // The value is most likely not a valid HTML attribute.
+      "data-value": e.props.value
+      // Instead, we provide it as a data attribute.
+    });
+  });
+  process.env.NODE_ENV !== "production" && a.useEffect(() => {
+    if (!W && !f && o !== "") {
+      const e = D.map((n) => n.props.value);
+      console.warn([`MUI: You have provided an out-of-range value \`${o}\` for the select ${c ? `(name="${c}") ` : ""}component.`, "Consider providing a value that matches one of the available options or ''.", `The available values are ${e.filter((n) => n != null).map((n) => `\`${n}\``).join(", ") || '""'}.`].join(`
+`));
+    }
+  }, [W, D, f, c, o]), N && (f ? M.length === 0 ? v = null : v = M.reduce((e, n, l) => (e.push(n), l < M.length - 1 && e.push(", "), e), []) : v = te);
+  let ne = Ee;
+  !p && V && E && (ne = d.clientWidth);
+  let k;
+  typeof J < "u" ? k = J : k = C ? null : 0;
+  const oe = F.id || (c ? `mui-component-select-${c}` : void 0), y = {
+    ...r,
+    variant: Se,
+    value: o,
+    open: b,
+    error: $
+  }, T = Qe(y), U = {
+    ...u.PaperProps,
+    ...typeof u.slotProps?.paper == "function" ? u.slotProps.paper(y) : u.slotProps?.paper
+  }, Re = {
+    ...u.MenuListProps,
+    ...typeof u.slotProps?.list == "function" ? u.slotProps.list(y) : u.slotProps?.list
+  }, re = ze();
+  return /* @__PURE__ */ S.jsxs(a.Fragment, {
+    children: [/* @__PURE__ */ S.jsx(He, {
+      as: "div",
+      ref: xe,
+      tabIndex: k,
+      role: "combobox",
+      "aria-controls": b ? re : void 0,
+      "aria-disabled": C ? "true" : void 0,
+      "aria-expanded": b ? "true" : "false",
+      "aria-haspopup": "listbox",
+      "aria-label": j,
+      "aria-labelledby": [w, oe].filter(Boolean).join(" ") || void 0,
+      "aria-describedby": x,
+      "aria-required": G ? "true" : void 0,
+      "aria-invalid": $ ? "true" : void 0,
+      onKeyDown: Me,
+      onMouseDown: C || H ? null : Ce,
+      onBlur: Ne,
+      onFocus: be,
+      ...F,
+      ownerState: y,
+      className: Fe(F.className, T.select, ce),
+      id: oe,
+      children: Je(v) ? (
+        // notranslate needed while Google Translate will not fix zero-width space issue
+        se || (se = /* @__PURE__ */ S.jsx("span", {
+          className: "notranslate",
+          "aria-hidden": !0,
+          children: "​"
+        }))
+      ) : v
+    }), /* @__PURE__ */ S.jsx(Ge, {
+      "aria-invalid": $,
+      value: Array.isArray(o) ? o.join(",") : o,
+      name: c,
+      ref: ee,
+      "aria-hidden": !0,
+      onChange: Oe,
+      tabIndex: -1,
+      disabled: C,
+      className: T.nativeInput,
+      autoFocus: g,
+      required: G,
+      ...Q,
+      ownerState: y
+    }), /* @__PURE__ */ S.jsx(Ye, {
+      as: fe,
+      className: T.icon,
+      ownerState: y
+    }), /* @__PURE__ */ S.jsx(Ve, {
+      id: `menu-${c || ""}`,
+      anchorEl: d,
+      open: b,
+      onClose: Pe,
+      anchorOrigin: {
+        vertical: "bottom",
+        horizontal: "center"
+      },
+      transformOrigin: {
+        vertical: "top",
+        horizontal: "center"
+      },
+      ...u,
+      slotProps: {
+        ...u.slotProps,
+        list: {
+          "aria-labelledby": w,
+          role: "listbox",
+          "aria-multiselectable": f ? "true" : void 0,
+          disableListWrap: !0,
+          id: re,
+          ...Re
+        },
+        paper: {
+          ...U,
+          style: {
+            minWidth: ne,
+            ...U != null ? U.style : null
+          }
+        }
+      },
+      children: je
+    })]
   });
 });
-process.env.NODE_ENV !== "production" && (J.propTypes = {
-  // ┌────────────────────────────── Warning ──────────────────────────────┐
-  // │ These PropTypes are generated from the TypeScript type definitions. │
-  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
-  // └─────────────────────────────────────────────────────────────────────┘
+process.env.NODE_ENV !== "production" && (Xe.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.
+   * @ignore
    */
-  addEndListener: n.func,
+  "aria-describedby": t.string,
   /**
-   * Perform the enter transition when it first mounts if `in` is also `true`.
-   * Set this to `false` to disable this behavior.
-   * @default true
+   * @ignore
    */
-  appear: n.bool,
+  "aria-label": t.string,
   /**
-   * A single child content element.
+   * @ignore
    */
-  children: G.isRequired,
+  autoFocus: t.bool,
   /**
-   * The transition timing function.
-   * You may specify a single easing or a object containing enter and exit values.
+   * If `true`, the width of the popover will automatically be set according to the items inside the
+   * menu, otherwise it will be at least the width of the select input.
    */
-  easing: n.oneOfType([n.shape({
-    enter: n.string,
-    exit: n.string
-  }), n.string]),
+  autoWidth: t.bool,
   /**
-   * If `true`, the component will transition in.
+   * The option elements to populate the select with.
+   * Can be some `<MenuItem>` elements.
    */
-  in: n.bool,
+  children: t.node,
   /**
-   * @ignore
+   * Override or extend the styles applied to the component.
    */
-  onEnter: n.func,
+  classes: t.object,
   /**
-   * @ignore
+   * The CSS class name of the select element.
+   */
+  className: t.string,
+  /**
+   * If `true`, the component is toggled on mount. Use when the component open state is not controlled.
+   * You can only use it when the `native` prop is `false` (default).
+   */
+  defaultOpen: t.bool,
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: t.any,
+  /**
+   * If `true`, the select is disabled.
+   */
+  disabled: t.bool,
+  /**
+   * If `true`, the selected item is displayed even if its value is empty.
    */
-  onEntered: n.func,
+  displayEmpty: t.bool,
+  /**
+   * If `true`, the `select input` will indicate an error.
+   */
+  error: t.bool,
+  /**
+   * The icon that displays the arrow.
+   */
+  IconComponent: t.elementType.isRequired,
+  /**
+   * Imperative handle implementing `{ value: T, node: HTMLElement, focus(): void }`
+   * Equivalent to `ref`
+   */
+  inputRef: _e,
+  /**
+   * The ID of an element that acts as an additional label. The Select will
+   * be labelled by the additional label and the selected value.
+   */
+  labelId: t.string,
+  /**
+   * Props applied to the [`Menu`](/material-ui/api/menu/) element.
+   */
+  MenuProps: t.object,
+  /**
+   * If `true`, `value` must be an array and the menu will support multiple selections.
+   */
+  multiple: t.bool,
+  /**
+   * Name attribute of the `select` or hidden `input` element.
+   */
+  name: t.string,
   /**
    * @ignore
    */
-  onEntering: n.func,
+  onBlur: t.func,
+  /**
+   * Callback fired when a menu item is selected.
+   *
+   * @param {object} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (any).
+   * @param {object} [child] The react element that was selected.
+   */
+  onChange: t.func,
+  /**
+   * Callback fired when the component requests to be closed.
+   * Use in controlled mode (see open).
+   *
+   * @param {object} event The event source of the callback.
+   */
+  onClose: t.func,
   /**
    * @ignore
    */
-  onExit: n.func,
+  onFocus: t.func,
+  /**
+   * Callback fired when the component requests to be opened.
+   * Use in controlled mode (see open).
+   *
+   * @param {object} event The event source of the callback.
+   */
+  onOpen: t.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: t.bool,
   /**
    * @ignore
    */
-  onExited: n.func,
+  readOnly: t.bool,
+  /**
+   * Render the selected value.
+   *
+   * @param {any} value The `value` provided to the component.
+   * @returns {ReactNode}
+   */
+  renderValue: t.func,
+  /**
+   * If `true`, the component is required.
+   */
+  required: t.bool,
+  /**
+   * Props applied to the clickable div element.
+   */
+  SelectDisplayProps: t.object,
   /**
    * @ignore
    */
-  onExiting: n.func,
+  tabIndex: t.oneOfType([t.number, t.string]),
   /**
    * @ignore
    */
-  style: n.object,
+  type: t.any,
+  /**
+   * The input value.
+   */
+  value: t.any,
   /**
-   * The duration for the transition, in milliseconds.
-   * You may specify a single timeout for all transitions, or individually with an object.
-   * @default {
-   *   enter: theme.transitions.duration.enteringScreen,
-   *   exit: theme.transitions.duration.leavingScreen,
-   * }
+   * The variant to use.
    */
-  timeout: n.oneOfType([n.number, n.shape({
-    appear: n.number,
-    enter: n.number,
-    exit: n.number
-  })])
+  variant: t.oneOf(["standard", "outlined", "filled"])
 });
 export {
-  J as default
+  Xe as default
 };
 //# sourceMappingURL=ui-components.es314.js.map