@als-tp/als-react-ts-ui 0.3.1 → 0.5.0

package/dist/als-react-ts-ui179.js

@@ -0,0 +1,101 @@
+import * as e from "react";
+import { useStableCallback as m } from "./als-react-ts-ui192.js";
+import { FieldRootContext as G } from "./als-react-ts-ui398.js";
+import { DEFAULT_VALIDITY_STATE as H, fieldValidityMapping as J } from "./als-react-ts-ui409.js";
+import { useFieldsetRootContext as K } from "./als-react-ts-ui418.js";
+import { useFormContext as Q } from "./als-react-ts-ui402.js";
+import { useRenderElement as W } from "./als-react-ts-ui189.js";
+import { useFieldValidation as X } from "./als-react-ts-ui419.js";
+import { jsx as y } from "react/jsx-runtime";
+import { LabelableProvider as Z } from "./als-react-ts-ui420.js";
+const C = /* @__PURE__ */ e.forwardRef(function(o, p) {
+  const {
+    errors: h,
+    validationMode: A,
+    submitAttemptedRef: I
+  } = Q(), {
+    render: ee,
+    className: te,
+    validate: g,
+    validationDebounceTime: v = 0,
+    validationMode: i = A,
+    name: t,
+    disabled: O = !1,
+    invalid: _,
+    dirty: D,
+    touched: S,
+    ...L
+  } = o, {
+    disabled: U
+  } = K(), R = m(g || (() => null)), r = U || O, [k, j] = e.useState(!1), [B, Y] = e.useState(!1), [n, V] = e.useState(!1), [a, P] = e.useState(!1), d = D ?? B, s = S ?? k, F = e.useRef(!1), E = m((f) => {
+    D === void 0 && (f && (F.current = !0), Y(f));
+  }), M = m((f) => {
+    S === void 0 && j(f);
+  }), b = m(() => i === "onChange" || i === "onSubmit" && I.current), l = !!(_ || t && {}.hasOwnProperty.call(h, t) && h[t] !== void 0), [c, N] = e.useState({
+    state: H,
+    error: "",
+    errors: [],
+    value: null,
+    initialValue: null
+  }), T = !l && c.state.valid, u = e.useMemo(() => ({
+    disabled: r,
+    touched: s,
+    dirty: d,
+    valid: T,
+    filled: n,
+    focused: a
+  }), [r, s, d, T, n, a]), x = X({
+    setValidityData: N,
+    validate: R,
+    validityData: c,
+    validationDebounceTime: v,
+    invalid: l,
+    markedDirtyRef: F,
+    state: u,
+    name: t,
+    shouldValidateOnChange: b
+  }), q = e.useMemo(() => ({
+    invalid: l,
+    name: t,
+    validityData: c,
+    setValidityData: N,
+    disabled: r,
+    touched: s,
+    setTouched: M,
+    dirty: d,
+    setDirty: E,
+    filled: n,
+    setFilled: V,
+    focused: a,
+    setFocused: P,
+    validate: R,
+    validationMode: i,
+    validationDebounceTime: v,
+    shouldValidateOnChange: b,
+    state: u,
+    markedDirtyRef: F,
+    validation: x
+  }), [l, t, c, r, s, M, d, E, n, V, a, P, R, i, v, b, u, x]), z = W("div", o, {
+    ref: p,
+    state: u,
+    props: L,
+    stateAttributesMapping: J
+  });
+  return /* @__PURE__ */ y(G.Provider, {
+    value: q,
+    children: z
+  });
+});
+process.env.NODE_ENV !== "production" && (C.displayName = "FieldRootInner");
+const $ = /* @__PURE__ */ e.forwardRef(function(o, p) {
+  return /* @__PURE__ */ y(Z, {
+    children: /* @__PURE__ */ y(C, {
+      ...o,
+      ref: p
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && ($.displayName = "FieldRoot");
+export {
+  $ as FieldRoot
+};

package/dist/als-react-ts-ui18.js

@@ -0,0 +1,32 @@
+import { ALSMenuSubmenuContent as e, ALSMenuSubmenuTrigger as u, ALSMenuSubmenuRoot as o, ALSMenuRadioItem as n, ALSMenuRadioGroup as t, ALSMenuCheckboxItem as S, ALSMenuGroupLabel as r, ALSMenuGroup as L, ALSMenuSeparator as m, ALSMenuItem as A, ALSMenuContent as M, ALSMenuTrigger as a, ALSMenuRoot as b } from "./als-react-ts-ui74.js";
+const i = {
+  /** Root container for the menu */
+  Root: b,
+  /** Button that triggers the menu */
+  Trigger: a,
+  /** Popup container for menu items */
+  Content: M,
+  /** Individual menu item */
+  Item: A,
+  /** Visual separator between items */
+  Separator: m,
+  /** Group of related menu items */
+  Group: L,
+  /** Label for a group of items */
+  GroupLabel: r,
+  /** Checkbox menu item */
+  CheckboxItem: S,
+  /** Group for radio items */
+  RadioGroup: t,
+  /** Radio menu item */
+  RadioItem: n,
+  /** Root for a submenu */
+  SubmenuRoot: o,
+  /** Trigger for a submenu */
+  SubmenuTrigger: u,
+  /** Content container for a submenu */
+  SubmenuContent: e
+};
+export {
+  i as ALSMenu
+};

package/dist/als-react-ts-ui180.js

@@ -0,0 +1,38 @@
+import * as i from "react";
+import { useIsoLayoutEffect as u } from "./als-react-ts-ui193.js";
+import { useFieldRootContext as p } from "./als-react-ts-ui398.js";
+import { useLabelableContext as c } from "./als-react-ts-ui399.js";
+import { fieldValidityMapping as b } from "./als-react-ts-ui409.js";
+import { useBaseUiId as R } from "./als-react-ts-ui249.js";
+import { useRenderElement as g } from "./als-react-ts-ui189.js";
+import { getTarget as L } from "./als-react-ts-ui331.js";
+const x = /* @__PURE__ */ i.forwardRef(function(r, l) {
+  const {
+    render: F,
+    className: I,
+    id: n,
+    ...a
+  } = r, s = p(!1), {
+    controlId: d,
+    setLabelId: t,
+    labelId: f
+  } = c(), o = R(n), m = i.useRef(null);
+  return u(() => (o && t(o), () => {
+    t(void 0);
+  }), [o, t]), g("label", r, {
+    ref: [l, m],
+    state: s.state,
+    props: [{
+      id: f,
+      htmlFor: d ?? void 0,
+      onMouseDown(e) {
+        L(e.nativeEvent)?.closest("button,input,select,textarea") || !e.defaultPrevented && e.detail > 1 && e.preventDefault();
+      }
+    }, a],
+    stateAttributesMapping: b
+  });
+});
+process.env.NODE_ENV !== "production" && (x.displayName = "FieldLabel");
+export {
+  x as FieldLabel
+};

package/dist/als-react-ts-ui181.js

@@ -0,0 +1,97 @@
+import * as p from "react";
+import { useStableCallback as x } from "./als-react-ts-ui192.js";
+import { useControlled as L } from "./als-react-ts-ui282.js";
+import { useIsoLayoutEffect as k } from "./als-react-ts-ui193.js";
+import { useFieldRootContext as b } from "./als-react-ts-ui398.js";
+import { useLabelableContext as B } from "./als-react-ts-ui399.js";
+import { useLabelableId as S } from "./als-react-ts-ui400.js";
+import { fieldValidityMapping as U } from "./als-react-ts-ui409.js";
+import { useRenderElement as A } from "./als-react-ts-ui189.js";
+import { useField as K } from "./als-react-ts-ui403.js";
+import { createChangeEventDetails as O } from "./als-react-ts-ui246.js";
+import { none as _ } from "./als-react-ts-ui248.js";
+const j = /* @__PURE__ */ p.forwardRef(function(n, C) {
+  const {
+    render: z,
+    className: G,
+    id: g,
+    name: v,
+    value: o,
+    disabled: R = !1,
+    onValueChange: V,
+    defaultValue: i,
+    ...F
+  } = n, {
+    state: s,
+    name: y,
+    disabled: E
+  } = b(), l = E || R, u = y ?? v, N = p.useMemo(() => ({
+    ...s,
+    disabled: l
+  }), [s, l]), {
+    setTouched: d,
+    setDirty: P,
+    validityData: T,
+    setFocused: m,
+    setFilled: r,
+    validationMode: h,
+    validation: t
+  } = b(), {
+    labelId: D
+  } = B(), f = S({
+    id: g
+  });
+  k(() => {
+    const e = o != null;
+    t.inputRef.current?.value || e && o !== "" ? r(!0) : e && o === "" && r(!1);
+  }, [t.inputRef, r, o]);
+  const [c, I] = L({
+    controlled: o,
+    default: i,
+    name: "FieldControl",
+    state: "value"
+  }), M = o !== void 0, w = x((e, a) => {
+    V?.(e, a), !a.isCanceled && I(e);
+  });
+  return K({
+    id: f,
+    name: u,
+    commit: t.commit,
+    value: c,
+    getValue: () => t.inputRef.current?.value,
+    controlRef: t.inputRef
+  }), A("input", n, {
+    ref: C,
+    state: N,
+    props: [{
+      id: f,
+      disabled: l,
+      name: u,
+      ref: t.inputRef,
+      "aria-labelledby": D,
+      ...M ? {
+        value: c
+      } : {
+        defaultValue: i
+      },
+      onChange(e) {
+        const a = e.currentTarget.value;
+        w(a, O(_, e.nativeEvent)), P(a !== T.initialValue), r(a !== "");
+      },
+      onFocus() {
+        m(!0);
+      },
+      onBlur(e) {
+        d(!0), m(!1), h === "onBlur" && t.commit(e.currentTarget.value);
+      },
+      onKeyDown(e) {
+        e.currentTarget.tagName === "INPUT" && e.key === "Enter" && (d(!0), t.commit(e.currentTarget.value));
+      }
+    }, t.getInputValidationProps(), F],
+    stateAttributesMapping: U
+  });
+});
+process.env.NODE_ENV !== "production" && (j.displayName = "FieldControl");
+export {
+  j as FieldControl
+};

package/dist/als-react-ts-ui182.js

@@ -0,0 +1,34 @@
+import * as f from "react";
+import { useIsoLayoutEffect as d } from "./als-react-ts-ui193.js";
+import { useFieldRootContext as m } from "./als-react-ts-ui398.js";
+import { useLabelableContext as l } from "./als-react-ts-ui399.js";
+import { fieldValidityMapping as c } from "./als-react-ts-ui409.js";
+import { useBaseUiId as u } from "./als-react-ts-ui249.js";
+import { useRenderElement as R } from "./als-react-ts-ui189.js";
+const x = /* @__PURE__ */ f.forwardRef(function(r, i) {
+  const {
+    render: E,
+    id: s,
+    className: F,
+    ...n
+  } = r, e = u(s), p = m(!1), {
+    setMessageIds: t
+  } = l();
+  return d(() => {
+    if (e)
+      return t((o) => o.concat(e)), () => {
+        t((o) => o.filter((a) => a !== e));
+      };
+  }, [e, t]), R("p", r, {
+    ref: i,
+    state: p.state,
+    props: [{
+      id: e
+    }, n],
+    stateAttributesMapping: c
+  });
+});
+process.env.NODE_ENV !== "production" && (x.displayName = "FieldDescription");
+export {
+  x as FieldDescription
+};

package/dist/als-react-ts-ui183.js

@@ -0,0 +1,48 @@
+import * as n from "react";
+import { useIsoLayoutEffect as F } from "./als-react-ts-ui193.js";
+import { useFieldRootContext as v } from "./als-react-ts-ui398.js";
+import { useLabelableContext as x } from "./als-react-ts-ui399.js";
+import { fieldValidityMapping as N } from "./als-react-ts-ui409.js";
+import { useFormContext as R } from "./als-react-ts-ui402.js";
+import { useRenderElement as b } from "./als-react-ts-ui189.js";
+import { useBaseUiId as g } from "./als-react-ts-ui249.js";
+const h = /* @__PURE__ */ n.forwardRef(function(l, m) {
+  const {
+    render: I,
+    id: d,
+    className: M,
+    match: i,
+    ...u
+  } = l, t = g(d), {
+    validityData: o,
+    state: c,
+    name: a
+  } = v(!1), {
+    setMessageIds: s
+  } = x(), {
+    errors: p
+  } = R(), f = a ? p[a] : null;
+  let e = !1;
+  f || i === !0 ? e = !0 : i ? e = !!o.state[i] : e = o.state.valid === !1, F(() => {
+    if (!(!e || !t))
+      return s((r) => r.concat(t)), () => {
+        s((r) => r.filter((y) => y !== t));
+      };
+  }, [e, t, s]);
+  const E = b("div", l, {
+    ref: m,
+    state: c,
+    props: [{
+      id: t,
+      children: f || (o.errors.length > 1 ? /* @__PURE__ */ n.createElement("ul", {}, o.errors.map((r) => /* @__PURE__ */ n.createElement("li", {
+        key: r
+      }, r))) : o.error)
+    }, u],
+    stateAttributesMapping: N
+  });
+  return e ? E : null;
+});
+process.env.NODE_ENV !== "production" && (h.displayName = "FieldError");
+export {
+  h as FieldError
+};

package/dist/als-react-ts-ui184.js

@@ -0,0 +1,9 @@
+const o = "_root_1as67_1", e = "_legend_1as67_8", t = {
+  root: o,
+  legend: e
+};
+export {
+  t as default,
+  e as legend,
+  o as root
+};

package/dist/als-react-ts-ui185.js

@@ -0,0 +1,32 @@
+import * as t from "react";
+import { FieldsetRootContext as m } from "./als-react-ts-ui418.js";
+import { useRenderElement as c } from "./als-react-ts-ui189.js";
+import { jsx as f } from "react/jsx-runtime";
+const u = /* @__PURE__ */ t.forwardRef(function(s, d) {
+  const {
+    render: R,
+    className: x,
+    disabled: e = !1,
+    ...n
+  } = s, [o, r] = t.useState(void 0), l = t.useMemo(() => ({
+    disabled: e
+  }), [e]), i = c("fieldset", s, {
+    ref: d,
+    state: l,
+    props: [{
+      "aria-labelledby": o
+    }, n]
+  }), a = t.useMemo(() => ({
+    legendId: o,
+    setLegendId: r,
+    disabled: e
+  }), [o, r, e]);
+  return /* @__PURE__ */ f(m.Provider, {
+    value: a,
+    children: i
+  });
+});
+process.env.NODE_ENV !== "production" && (u.displayName = "FieldsetRoot");
+export {
+  u as FieldsetRoot
+};

package/dist/als-react-ts-ui186.js

@@ -0,0 +1,33 @@
+import * as d from "react";
+import { useIsoLayoutEffect as f } from "./als-react-ts-ui193.js";
+import { useBaseUiId as a } from "./als-react-ts-ui249.js";
+import { useRenderElement as l } from "./als-react-ts-ui189.js";
+import { useFieldsetRootContext as c } from "./als-react-ts-ui418.js";
+const p = /* @__PURE__ */ d.forwardRef(function(s, r) {
+  const {
+    render: L,
+    className: g,
+    id: n,
+    ...i
+  } = s, {
+    disabled: o,
+    setLegendId: e
+  } = c(), t = a(n);
+  f(() => (e(t), () => {
+    e(void 0);
+  }), [e, t]);
+  const m = d.useMemo(() => ({
+    disabled: o ?? !1
+  }), [o]);
+  return l("div", s, {
+    state: m,
+    ref: r,
+    props: [{
+      id: t
+    }, i]
+  });
+});
+process.env.NODE_ENV !== "production" && (p.displayName = "FieldsetLegend");
+export {
+  p as FieldsetLegend
+};

package/dist/als-react-ts-ui187.js

@@ -0,0 +1,58 @@
+const o = "_root_1351o_9", _ = "_field_1351o_21", t = "_label_1351o_26", e = "_control_1351o_86", r = "_textarea_1351o_87", l = "_required_1351o_133", n = "_error_1351o_247", i = "_description_1351o_273", a = "_actions_1351o_285", s = "_group_1351o_311", c = "_groupTitle_1351o_322", g = "_groupDescription_1351o_332", d = "_groupContent_1351o_340", p = "_row_1351o_349", u = {
+  root: o,
+  "layout-vertical": "_layout-vertical_1351o_17",
+  "layout-horizontal": "_layout-horizontal_1351o_21",
+  field: _,
+  label: t,
+  "layout-inline": "_layout-inline_1351o_31",
+  "size-sm": "_size-sm_1351o_44",
+  "size-md": "_size-md_1351o_48",
+  "size-lg": "_size-lg_1351o_52",
+  "field-vertical": "_field-vertical_1351o_66",
+  "field-horizontal": "_field-horizontal_1351o_70",
+  "field-inline": "_field-inline_1351o_76",
+  control: e,
+  textarea: r,
+  "label-sm": "_label-sm_1351o_115",
+  "label-md": "_label-md_1351o_119",
+  "label-lg": "_label-lg_1351o_123",
+  required: l,
+  "control-sm": "_control-sm_1351o_172",
+  "control-md": "_control-md_1351o_178",
+  "control-lg": "_control-lg_1351o_184",
+  "textarea-sm": "_textarea-sm_1351o_226",
+  "textarea-md": "_textarea-md_1351o_232",
+  "textarea-lg": "_textarea-lg_1351o_238",
+  error: n,
+  description: i,
+  actions: a,
+  "actions-left": "_actions-left_1351o_292",
+  "actions-center": "_actions-center_1351o_296",
+  "actions-right": "_actions-right_1351o_300",
+  "actions-between": "_actions-between_1351o_304",
+  group: s,
+  groupTitle: c,
+  groupDescription: g,
+  groupContent: d,
+  row: p,
+  "row-gap-sm": "_row-gap-sm_1351o_360",
+  "row-gap-md": "_row-gap-md_1351o_364",
+  "row-gap-lg": "_row-gap-lg_1351o_368"
+};
+export {
+  a as actions,
+  e as control,
+  u as default,
+  i as description,
+  n as error,
+  _ as field,
+  s as group,
+  d as groupContent,
+  g as groupDescription,
+  c as groupTitle,
+  t as label,
+  l as required,
+  o as root,
+  p as row,
+  r as textarea
+};

package/dist/als-react-ts-ui188.js

@@ -0,0 +1,75 @@
+import * as t from "react";
+import { useStableCallback as b } from "./als-react-ts-ui192.js";
+import { createGenericEventDetails as S } from "./als-react-ts-ui246.js";
+import { FormContext as V } from "./als-react-ts-ui402.js";
+import { useRenderElement as g } from "./als-react-ts-ui189.js";
+import { useValueChanged as C } from "./als-react-ts-ui406.js";
+import { jsx as A } from "react/jsx-runtime";
+import { EMPTY_OBJECT as y } from "./als-react-ts-ui303.js";
+import { none as M } from "./als-react-ts-ui248.js";
+const P = /* @__PURE__ */ t.forwardRef(function(u, F) {
+  const {
+    render: O,
+    className: T,
+    validationMode: m = "onSubmit",
+    errors: n,
+    onSubmit: h,
+    onFormSubmit: c,
+    ...x
+  } = u, s = t.useRef({
+    fields: /* @__PURE__ */ new Map()
+  }), i = t.useRef(!1), d = t.useRef(!1), f = b((e) => {
+    e && (e.focus(), e.tagName === "INPUT" && e.select());
+  }), [o, p] = t.useState(n);
+  C(n, () => {
+    p(n);
+  }), t.useEffect(() => {
+    if (!i.current)
+      return;
+    i.current = !1;
+    const e = Array.from(s.current.fields.values()).filter((r) => r.validityData.state.valid === !1);
+    e.length && f(e[0].controlRef.current);
+  }, [o, f]);
+  const D = g("form", u, {
+    ref: F,
+    props: [{
+      noValidate: !0,
+      onSubmit(e) {
+        d.current = !0;
+        let r = Array.from(s.current.fields.values());
+        r.forEach((a) => {
+          a.validate();
+        }), r = Array.from(s.current.fields.values());
+        const E = r.filter((a) => !a.validityData.state.valid);
+        if (E.length)
+          e.preventDefault(), f(E[0].controlRef.current);
+        else if (i.current = !0, h?.(e), c) {
+          e.preventDefault();
+          const a = r.reduce((R, l) => (l.name && (R[l.name] = l.getValue()), R), {});
+          c(a, S(M, e.nativeEvent));
+        }
+      }
+    }, x]
+  }), v = b((e) => {
+    if (e && o && y.hasOwnProperty.call(o, e)) {
+      const r = {
+        ...o
+      };
+      delete r[e], p(r);
+    }
+  }), N = t.useMemo(() => ({
+    formRef: s,
+    validationMode: m,
+    errors: o ?? y,
+    clearErrors: v,
+    submitAttemptedRef: d
+  }), [s, m, o, v]);
+  return /* @__PURE__ */ A(V.Provider, {
+    value: N,
+    children: D
+  });
+});
+process.env.NODE_ENV !== "production" && (P.displayName = "Form");
+export {
+  P as Form
+};

package/dist/als-react-ts-ui189.js

@@ -0,0 +1,57 @@
+import R from "./als-react-ts-ui259.js";
+import * as P from "react";
+import { createElement as d } from "react";
+import { useMergedRefs as p, useMergedRefsN as b } from "./als-react-ts-ui287.js";
+import { getReactElementRef as y } from "./als-react-ts-ui298.js";
+import { mergeObjects as g } from "./als-react-ts-ui299.js";
+import { getStateAttributesProps as A } from "./als-react-ts-ui300.js";
+import { resolveClassName as M } from "./als-react-ts-ui301.js";
+import { resolveStyle as k } from "./als-react-ts-ui302.js";
+import { EMPTY_OBJECT as f } from "./als-react-ts-ui303.js";
+import { mergePropsN as v, mergeClassNames as C, mergeProps as O } from "./als-react-ts-ui304.js";
+function Y(r, e, t = {}) {
+  const i = e.render, o = w(e, t);
+  if (t.enabled === !1)
+    return null;
+  const m = t.state ?? f;
+  return B(r, i, o, m);
+}
+function w(r, e = {}) {
+  const {
+    className: t,
+    style: i,
+    render: o
+  } = r, {
+    state: m = f,
+    ref: u,
+    props: a,
+    stateAttributesMapping: E,
+    enabled: s = !0
+  } = e, l = s ? M(t, m) : void 0, c = s ? k(i, m) : void 0, N = s ? A(m, E) : f, n = s ? g(N, Array.isArray(a) ? v(a) : a) ?? f : f;
+  return typeof document < "u" && (s ? Array.isArray(u) ? n.ref = b([n.ref, y(o), ...u]) : n.ref = p(n.ref, y(o), u) : p(null, null)), s ? (l !== void 0 && (n.className = C(n.className, l)), c !== void 0 && (n.style = g(n.style, c)), n) : f;
+}
+function B(r, e, t, i) {
+  if (e) {
+    if (typeof e == "function")
+      return e(t, i);
+    const o = O(t, e.props);
+    return o.ref = t.ref, /* @__PURE__ */ P.cloneElement(e, o);
+  }
+  if (r && typeof r == "string")
+    return S(r, t);
+  throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: Render element or function are not defined." : R(8));
+}
+function S(r, e) {
+  return r === "button" ? /* @__PURE__ */ d("button", {
+    type: "button",
+    ...e,
+    key: e.key
+  }) : r === "img" ? /* @__PURE__ */ d("img", {
+    alt: "",
+    ...e,
+    key: e.key
+  }) : /* @__PURE__ */ P.createElement(r, e);
+}
+export {
+  Y as useRenderElement
+};

package/dist/als-react-ts-ui19.js

@@ -0,0 +1,8 @@
+import { ALSMenubarRoot as o } from "./als-react-ts-ui75.js";
+const t = {
+  /** Root container for the menubar */
+  Root: o
+};
+export {
+  t as ALSMenubar
+};

package/dist/als-react-ts-ui190.js

@@ -0,0 +1,14 @@
+import r from "./als-react-ts-ui259.js";
+import * as o from "react";
+const e = /* @__PURE__ */ o.createContext(void 0);
+process.env.NODE_ENV !== "production" && (e.displayName = "AvatarRootContext");
+function a() {
+  const t = o.useContext(e);
+  if (t === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: AvatarRootContext is missing. Avatar parts must be placed within <Avatar.Root>." : r(13));
+  return t;
+}
+export {
+  e as AvatarRootContext,
+  a as useAvatarRootContext
+};

package/dist/als-react-ts-ui191.js

@@ -0,0 +1,6 @@
+const t = {
+  imageLoadingStatus: () => null
+};
+export {
+  t as avatarStateAttributesMapping
+};

package/dist/als-react-ts-ui192.js

@@ -0,0 +1,29 @@
+import * as a from "react";
+import { useRefWithInit as c } from "./als-react-ts-ui240.js";
+const n = a[`useInsertionEffect${Math.random().toFixed(1)}`.slice(0, -3)], r = (
+  // React 17 doesn't have useInsertionEffect.
+  n && // Preact replaces useInsertionEffect with useLayoutEffect and fires too late.
+  n !== a.useLayoutEffect ? n : (e) => e()
+);
+function f(e) {
+  const t = c(o).current;
+  return t.next = e, r(t.effect), t.trampoline;
+}
+function o() {
+  const e = {
+    next: void 0,
+    callback: l,
+    trampoline: (...t) => e.callback?.(...t),
+    effect: () => {
+      e.callback = e.next;
+    }
+  };
+  return e;
+}
+function l() {
+  if (process.env.NODE_ENV !== "production")
+    throw new Error("Base UI: Cannot call an event handler while rendering.");
+}
+export {
+  f as useStableCallback
+};