npm - @px-ui/core - Versions diffs - 1.23.0 → 1.24.0 - Mend

@px-ui/core 1.23.0 → 1.24.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (364) hide show

package/dist/node_modules/.pnpm/@base-ui-components_react@1.0.0-beta.4_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/react/esm/dialog/trigger/DialogTrigger.js ADDED Viewed

@@ -0,0 +1,38 @@
+import * as n from "react";
+import { useDialogRootContext as f } from "../root/DialogRootContext.js";
+import { useButton as l } from "../../use-button/useButton.js";
+import { useRenderElement as c } from "../../utils/useRenderElement.js";
+import { triggerOpenStateMapping as E } from "../../utils/popupStateMapping.js";
+import { CLICK_TRIGGER_IDENTIFIER as R } from "../../utils/constants.js";
+const d = /* @__PURE__ */ n.forwardRef(function(r, s) {
+  const {
+    render: I,
+    className: N,
+    disabled: t = !1,
+    nativeButton: i = !0,
+    ...a
+  } = r, {
+    store: e
+  } = f(), o = e.useState("open"), g = e.useState("triggerProps"), p = n.useMemo(() => ({
+    disabled: t,
+    open: o
+  }), [t, o]), {
+    getButtonProps: m,
+    buttonRef: u
+  } = l({
+    disabled: t,
+    native: i
+  });
+  return c("button", r, {
+    state: p,
+    ref: [u, s, e.getElementSetter("triggerElement")],
+    props: [g, {
+      [R]: ""
+    }, a, m],
+    stateAttributesMapping: E
+  });
+});
+process.env.NODE_ENV !== "production" && (d.displayName = "DialogTrigger");
+export {
+  d as DialogTrigger
+};

@@ -0,0 +1,13 @@
+import * as t from "react";
+const n = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (n.displayName = "DirectionContext");
+function o(i = !0) {
+  const e = t.useContext(n);
+  if (e === void 0 && !i)
+    throw new Error("Base UI: DirectionContext is missing.");
+  return (e == null ? void 0 : e.direction) ?? "ltr";
+}
+export {
+  n as DirectionContext,
+  o as useDirection
+};

@@ -0,0 +1,104 @@
+import * as g from "react";
+import { useEventCallback as K } from "../../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useEventCallback.js";
+import { useControlled as L } from "../../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useControlled.js";
+import { useIsoLayoutEffect as V } from "../../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useIsoLayoutEffect.js";
+import { useFieldRootContext as b } from "../root/FieldRootContext.js";
+import { fieldValidityMapping as O } from "../utils/constants.js";
+import { useRenderElement as S } from "../../utils/useRenderElement.js";
+import { useField as _ } from "../useField.js";
+import { useBaseUiId as j } from "../../utils/useBaseUiId.js";
+import { useFieldControlValidation as q } from "./useFieldControlValidation.js";
+import { createChangeEventDetails as z } from "../../utils/createBaseUIEventDetails.js";
+const G = /* @__PURE__ */ g.forwardRef(function(u, F) {
+  const {
+    render: J,
+    className: Q,
+    id: E,
+    name: y,
+    value: o,
+    disabled: N = !1,
+    onValueChange: n,
+    defaultValue: f,
+    ...P
+  } = u, {
+    state: m,
+    name: I,
+    disabled: R
+  } = b(), i = R || N, c = I ?? y, T = g.useMemo(() => ({
+    ...m,
+    disabled: i
+  }), [m, i]), {
+    setControlId: s,
+    labelId: D,
+    setTouched: p,
+    setDirty: M,
+    validityData: h,
+    setFocused: v,
+    setFilled: a,
+    validationMode: w
+  } = b(), {
+    getValidationProps: B,
+    getInputValidationProps: U,
+    commitValidation: d,
+    inputRef: r
+  } = q(), l = j(E);
+  V(() => (s(l), () => {
+    s(void 0);
+  }), [l, s]), V(() => {
+    var t;
+    const e = o != null;
+    (t = r.current) != null && t.value || e && o !== "" ? a(!0) : e && o === "" && a(!1);
+  }, [r, a, o]);
+  const [C, k] = L({
+    controlled: o,
+    default: f,
+    name: "FieldControl",
+    state: "value"
+  }), x = o !== void 0, A = K((e, t) => {
+    n == null || n(e, t), !t.isCanceled && k(e);
+  });
+  return _({
+    id: l,
+    name: c,
+    commitValidation: d,
+    value: C,
+    getValue: () => {
+      var e;
+      return (e = r.current) == null ? void 0 : e.value;
+    },
+    controlRef: r
+  }), S("input", u, {
+    ref: F,
+    state: T,
+    props: [{
+      id: l,
+      disabled: i,
+      name: c,
+      ref: r,
+      "aria-labelledby": D,
+      ...x ? {
+        value: C
+      } : {
+        defaultValue: f
+      },
+      onChange(e) {
+        const t = e.currentTarget.value;
+        A(t, z("none", e.nativeEvent)), M(t !== h.initialValue), a(t !== "");
+      },
+      onFocus() {
+        v(!0);
+      },
+      onBlur(e) {
+        p(!0), v(!1), w === "onBlur" && d(e.currentTarget.value);
+      },
+      onKeyDown(e) {
+        e.currentTarget.tagName === "INPUT" && e.key === "Enter" && (p(!0), d(e.currentTarget.value));
+      }
+    }, B(), U(), P],
+    stateAttributesMapping: O
+  });
+});
+process.env.NODE_ENV !== "production" && (G.displayName = "FieldControl");
+export {
+  G as FieldControl
+};

@@ -0,0 +1,6 @@
+let a = /* @__PURE__ */ function(d) {
+  return d.disabled = "data-disabled", d.valid = "data-valid", d.invalid = "data-invalid", d.touched = "data-touched", d.dirty = "data-dirty", d.filled = "data-filled", d.focused = "data-focused", d;
+}({});
+export {
+  a as FieldControlDataAttributes
+};

@@ -0,0 +1,145 @@
+import * as p from "react";
+import { useTimeout as _ } from "../../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useTimeout.js";
+import { useEventCallback as w } from "../../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useEventCallback.js";
+import { useFieldRootContext as K } from "../root/FieldRootContext.js";
+import { DEFAULT_VALIDITY_STATE as S } from "../utils/constants.js";
+import { useFormContext as U } from "../../form/FormContext.js";
+import { getCombinedFieldValidityData as O } from "../utils/getCombinedFieldValidityData.js";
+import { mergeProps as P } from "../../merge-props/mergeProps.js";
+const M = Object.keys(S);
+function Y(l) {
+  if (!l || l.valid || !l.valueMissing)
+    return !1;
+  let d = !1;
+  for (const s of M)
+    s !== "valid" && (s === "valueMissing" && (d = l[s]), l[s] && (d = !1));
+  return d;
+}
+function W() {
+  const {
+    setValidityData: l,
+    validate: d,
+    messageIds: s,
+    validityData: E,
+    validationMode: R,
+    validationDebounceTime: C,
+    invalid: D,
+    markedDirtyRef: L,
+    controlId: f,
+    state: b,
+    name: T
+  } = K(), {
+    formRef: c,
+    clearErrors: F
+  } = U(), g = _(), x = p.useRef(null), o = w(async (u, m = !1) => {
+    const i = x.current;
+    if (!i)
+      return;
+    if (m) {
+      if (b.valid !== !1)
+        return;
+      const n = i.validity;
+      if (!n.valueMissing) {
+        const a = {
+          value: u,
+          state: {
+            ...S,
+            valid: !0
+          },
+          error: "",
+          errors: [],
+          initialValue: E.initialValue
+        };
+        if (i.setCustomValidity(""), f) {
+          const e = c.current.fields.get(f);
+          e && c.current.fields.set(f, {
+            ...e,
+            ...O(a, !1)
+            // invalid = false
+          });
+        }
+        l(a);
+        return;
+      }
+      const t = M.reduce((a, e) => (a[e] = n[e], a), {});
+      if (!t.valid && !Y(t))
+        return;
+    }
+    function N(n) {
+      const t = M.reduce((e, v) => (e[v] = n.validity[v], e), {});
+      let a = !1;
+      for (const e of M)
+        if (e !== "valid") {
+          if (e === "valueMissing" && t[e])
+            a = !0;
+          else if (t[e])
+            return t;
+        }
+      return a && !L.current && (t.valid = !0, t.valueMissing = !1), t;
+    }
+    g.clear();
+    let r = null, V = [];
+    const A = N(i);
+    let j;
+    if (i.validationMessage)
+      j = i.validationMessage, V = [i.validationMessage];
+    else {
+      const n = Array.from(c.current.fields.values()).reduce((a, e) => {
+        var v, I;
+        return e.name && e.getValueRef && (a[e.name] = (I = (v = e.getValueRef).current) == null ? void 0 : I.call(v)), a;
+      }, {}), t = d(u, n);
+      typeof t == "object" && t !== null && "then" in t ? r = await t : r = t, r !== null && (A.valid = !1, A.customError = !0, Array.isArray(r) ? (V = r, i.setCustomValidity(r.join(`
+`))) : r && (V = [r], i.setCustomValidity(r)));
+    }
+    const k = {
+      value: u,
+      state: A,
+      error: j ?? (Array.isArray(r) ? r[0] : r ?? ""),
+      errors: V,
+      initialValue: E.initialValue
+    };
+    if (f) {
+      const n = c.current.fields.get(f);
+      n && c.current.fields.set(f, {
+        ...n,
+        ...O(k, D)
+      });
+    }
+    l(k);
+  }), y = p.useCallback((u = {}) => P({
+    ...s.length && {
+      "aria-describedby": s.join(" ")
+    },
+    ...b.valid === !1 && {
+      "aria-invalid": !0
+    }
+  }, u), [s, b.valid]), h = p.useCallback((u = {}) => P({
+    onChange(m) {
+      if (m.nativeEvent.defaultPrevented)
+        return;
+      if (F(T), R !== "onChange") {
+        o(m.currentTarget.value, !0);
+        return;
+      }
+      if (D)
+        return;
+      const i = m.currentTarget;
+      if (i.value === "") {
+        o(i.value);
+        return;
+      }
+      g.clear(), C ? g.start(C, () => {
+        o(i.value);
+      }) : o(i.value);
+    }
+  }, y(u)), [y, F, T, g, o, D, R, C]);
+  return p.useMemo(() => ({
+    getValidationProps: y,
+    getInputValidationProps: h,
+    inputRef: x,
+    commitValidation: o
+  }), [y, h, o]);
+}
+export {
+  W as useFieldControlValidation
+};

@@ -0,0 +1,55 @@
+import * as o from "react";
+import { DEFAULT_VALIDITY_STATE as l } from "../utils/constants.js";
+import { NOOP as e } from "../../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/empty.js";
+const d = /* @__PURE__ */ o.createContext({
+  invalid: void 0,
+  controlId: void 0,
+  setControlId: e,
+  labelId: void 0,
+  setLabelId: e,
+  messageIds: [],
+  setMessageIds: e,
+  name: void 0,
+  validityData: {
+    state: l,
+    errors: [],
+    error: "",
+    value: "",
+    initialValue: null
+  },
+  setValidityData: e,
+  disabled: void 0,
+  touched: !1,
+  setTouched: e,
+  dirty: !1,
+  setDirty: e,
+  filled: !1,
+  setFilled: e,
+  focused: !1,
+  setFocused: e,
+  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" && (d.displayName = "FieldRootContext");
+function n(i = !0) {
+  const t = o.useContext(d);
+  if (t.setControlId === e && !i)
+    throw new Error("Base UI: FieldRootContext is missing. Field parts must be placed within <Field.Root>.");
+  return t;
+}
+export {
+  d as FieldRootContext,
+  n as useFieldRootContext
+};

package/dist/node_modules/.pnpm/@base-ui-components_react@1.0.0-beta.4_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/react/esm/field/useField.js ADDED Viewed

@@ -0,0 +1,53 @@
+import * as V from "react-dom";
+import { useIsoLayoutEffect as u } from "../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useIsoLayoutEffect.js";
+import { useLatestRef as v } from "../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useLatestRef.js";
+import { getCombinedFieldValidityData as x } from "./utils/getCombinedFieldValidityData.js";
+import { useFormContext as F } from "../form/FormContext.js";
+import { useFieldRootContext as C } from "./root/FieldRootContext.js";
+function E(f) {
+  const {
+    formRef: o
+  } = F(), {
+    invalid: d,
+    markedDirtyRef: m,
+    validityData: r,
+    setValidityData: s
+  } = C(), {
+    enabled: a = !0,
+    value: l,
+    id: e,
+    name: c,
+    controlRef: y,
+    commitValidation: p
+  } = f, i = v(f.getValue);
+  u(() => {
+    var n;
+    if (!a)
+      return;
+    let t = l;
+    t === void 0 && (t = (n = i.current) == null ? void 0 : n.call(i)), r.initialValue === null && t !== r.initialValue && s((D) => ({
+      ...D,
+      initialValue: t
+    }));
+  }, [a, s, l, r.initialValue, i]), u(() => {
+    a && e && o.current.fields.set(e, {
+      controlRef: y,
+      validityData: x(r, d),
+      validate() {
+        var n;
+        let t = l;
+        t === void 0 && (t = (n = i.current) == null ? void 0 : n.call(i)), m.current = !0, V.flushSync(() => p(t));
+      },
+      getValueRef: i,
+      name: c
+    });
+  }, [p, y, a, o, i, e, d, m, c, r, l]), u(() => {
+    const t = o.current.fields;
+    return () => {
+      e && t.delete(e);
+    };
+  }, [o, e]);
+}
+export {
+  E as useField
+};

@@ -0,0 +1,26 @@
+import { FieldControlDataAttributes as a } from "../control/FieldControlDataAttributes.js";
+const e = {
+  badInput: !1,
+  customError: !1,
+  patternMismatch: !1,
+  rangeOverflow: !1,
+  rangeUnderflow: !1,
+  stepMismatch: !1,
+  tooLong: !1,
+  tooShort: !1,
+  typeMismatch: !1,
+  valid: null,
+  valueMissing: !1
+}, r = {
+  valid(l) {
+    return l === null ? null : l ? {
+      [a.valid]: ""
+    } : {
+      [a.invalid]: ""
+    };
+  }
+};
+export {
+  e as DEFAULT_VALIDITY_STATE,
+  r as fieldValidityMapping
+};

@@ -0,0 +1,12 @@
+function n(e, t) {
+  return {
+    ...e,
+    state: {
+      ...e.state,
+      valid: !t && e.state.valid
+    }
+  };
+}
+export {
+  n as getCombinedFieldValidityData
+};

@@ -0,0 +1,94 @@
+import * as r from "react";
+import { useTimeout as P, Timeout as x } from "../../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useTimeout.js";
+import { useIsoLayoutEffect as y } from "../../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useIsoLayoutEffect.js";
+import { getDelay as C } from "../hooks/useHover.js";
+import { createChangeEventDetails as E } from "../../utils/createBaseUIEventDetails.js";
+import { j as M } from "../../../../../../../../../_virtual/jsx-runtime.js";
+const h = /* @__PURE__ */ r.createContext({
+  hasProvider: !1,
+  timeoutMs: 0,
+  delayRef: {
+    current: 0
+  },
+  initialDelayRef: {
+    current: 0
+  },
+  timeout: new x(),
+  currentIdRef: {
+    current: null
+  },
+  currentContextRef: {
+    current: null
+  }
+});
+process.env.NODE_ENV !== "production" && (h.displayName = "FloatingDelayGroupContext");
+function O(R) {
+  const {
+    children: p,
+    delay: s,
+    timeoutMs: l = 0
+  } = R, o = r.useRef(s), a = r.useRef(s), I = r.useRef(null), t = r.useRef(null), n = P();
+  return /* @__PURE__ */ M.jsx(h.Provider, {
+    value: r.useMemo(() => ({
+      hasProvider: !0,
+      delayRef: o,
+      initialDelayRef: a,
+      currentIdRef: I,
+      timeoutMs: l,
+      currentContextRef: t,
+      timeout: n
+    }), [l, n]),
+    children: p
+  });
+}
+function T(R, p = {}) {
+  const {
+    open: s,
+    onOpenChange: l,
+    floatingId: o
+  } = R, {
+    enabled: a = !0
+  } = p, I = r.useContext(h), {
+    currentIdRef: t,
+    delayRef: n,
+    timeoutMs: d,
+    initialDelayRef: m,
+    currentContextRef: u,
+    hasProvider: D,
+    timeout: c
+  } = I, [g, i] = r.useState(!1);
+  return y(() => {
+    function e() {
+      var f;
+      i(!1), (f = u.current) == null || f.setIsInstantPhase(!1), t.current = null, u.current = null, n.current = m.current;
+    }
+    if (a && t.current && !s && t.current === o) {
+      if (i(!1), d)
+        return c.start(d, e), () => {
+          c.clear();
+        };
+      e();
+    }
+  }, [a, s, o, t, n, d, m, u, c]), y(() => {
+    if (!a || !s)
+      return;
+    const e = u.current, f = t.current;
+    u.current = {
+      onOpenChange: l,
+      setIsInstantPhase: i
+    }, t.current = o, n.current = {
+      open: 0,
+      close: C(m.current, "close")
+    }, f !== null && f !== o ? (c.clear(), i(!0), e == null || e.setIsInstantPhase(!0), e == null || e.onOpenChange(!1, E("none"))) : (i(!1), e == null || e.setIsInstantPhase(!1));
+  }, [a, s, o, l, t, n, d, m, u, c]), y(() => () => {
+    u.current = null;
+  }, [u]), r.useMemo(() => ({
+    hasProvider: D,
+    delayRef: n,
+    isInstantPhase: g
+  }), [D, n, g]);
+}
+export {
+  O as FloatingDelayGroup,
+  T as useDelayGroup
+};