@yselimcan/ui 0.0.2 → 0.0.4

package/dist/index208.js

@@ -0,0 +1,19 @@
+import * as n from "react";
+function e(i) {
+  const o = n.useRef(""), c = n.useCallback((r) => {
+    r.defaultPrevented || (o.current = r.pointerType, i(r, r.pointerType));
+  }, [i]);
+  return {
+    onClick: n.useCallback((r) => {
+      if (r.detail === 0) {
+        i(r, "keyboard");
+        return;
+      }
+      "pointerType" in r && i(r, r.pointerType), i(r, o.current), o.current = "";
+    }, [i]),
+    onPointerDown: c
+  };
+}
+export {
+  e as useEnhancedClickHandler
+};

package/dist/index209.js

@@ -0,0 +1,9 @@
+"use client";
+import * as e from "react";
+const n = [];
+function o(t) {
+  e.useEffect(t, n);
+}
+export {
+  o as useOnMount
+};

package/dist/index21.js

@@ -0,0 +1,40 @@
+"use client";
+import * as s from "react";
+import { useDialogRootContext as d } from "./index109.js";
+import { useRenderElement as m } from "./index86.js";
+import { popupStateMapping as l } from "./index111.js";
+import { transitionStatusMapping as f } from "./index112.js";
+const S = {
+  ...l,
+  ...f
+}, g = /* @__PURE__ */ s.forwardRef(function(t, r) {
+  const {
+    render: k,
+    className: D,
+    forceRender: a = !1,
+    ...i
+  } = t, {
+    store: e
+  } = d(), o = e.useState("open"), p = e.useState("nested"), c = e.useState("mounted"), n = e.useState("transitionStatus"), u = s.useMemo(() => ({
+    open: o,
+    transitionStatus: n
+  }), [o, n]);
+  return m("div", t, {
+    state: u,
+    ref: [e.context.backdropRef, r],
+    stateAttributesMapping: S,
+    props: [{
+      role: "presentation",
+      hidden: !c,
+      style: {
+        userSelect: "none",
+        WebkitUserSelect: "none"
+      }
+    }, i],
+    enabled: a || !p
+  });
+});
+process.env.NODE_ENV !== "production" && (g.displayName = "DialogBackdrop");
+export {
+  g as DialogBackdrop
+};

package/dist/index210.js

@@ -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
+};

package/dist/index211.js

@@ -0,0 +1,24 @@
+"use client";
+import * as e from "react";
+const t = /* @__PURE__ */ e.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  subscribeMapChange: () => () => {
+  },
+  elementsRef: {
+    current: []
+  },
+  nextIndexRef: {
+    current: 0
+  }
+});
+process.env.NODE_ENV !== "production" && (t.displayName = "CompositeListContext");
+function n() {
+  return e.useContext(t);
+}
+export {
+  t as CompositeListContext,
+  n as useCompositeListContext
+};

package/dist/index212.js

@@ -0,0 +1,130 @@
+const j = ["top", "right", "bottom", "left"], m = Math.min, p = Math.max, C = Math.round, L = Math.floor, E = (t) => ({
+  x: t,
+  y: t
+}), h = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, x = {
+  start: "end",
+  end: "start"
+};
+function R(t, e, n) {
+  return p(t, m(e, n));
+}
+function T(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function g(t) {
+  return t.split("-")[0];
+}
+function a(t) {
+  return t.split("-")[1];
+}
+function b(t) {
+  return t === "x" ? "y" : "x";
+}
+function d(t) {
+  return t === "y" ? "height" : "width";
+}
+const A = /* @__PURE__ */ new Set(["top", "bottom"]);
+function P(t) {
+  return A.has(g(t)) ? "y" : "x";
+}
+function y(t) {
+  return b(P(t));
+}
+function k(t, e, n) {
+  n === void 0 && (n = !1);
+  const r = a(t), i = y(t), o = d(i);
+  let c = i === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return e.reference[o] > e.floating[o] && (c = f(c)), [c, f(c)];
+}
+function q(t) {
+  const e = f(t);
+  return [s(t), e, s(e)];
+}
+function s(t) {
+  return t.replace(/start|end/g, (e) => x[e]);
+}
+const u = ["left", "right"], l = ["right", "left"], M = ["top", "bottom"], O = ["bottom", "top"];
+function S(t, e, n) {
+  switch (t) {
+    case "top":
+    case "bottom":
+      return n ? e ? l : u : e ? u : l;
+    case "left":
+    case "right":
+      return e ? M : O;
+    default:
+      return [];
+  }
+}
+function z(t, e, n, r) {
+  const i = a(t);
+  let o = S(g(t), n === "start", r);
+  return i && (o = o.map((c) => c + "-" + i), e && (o = o.concat(o.map(s)))), o;
+}
+function f(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => h[e]);
+}
+function w(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function B(t) {
+  return typeof t != "number" ? w(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function D(t) {
+  const {
+    x: e,
+    y: n,
+    width: r,
+    height: i
+  } = t;
+  return {
+    width: r,
+    height: i,
+    top: n,
+    left: e,
+    right: e + r,
+    bottom: n + i,
+    x: e,
+    y: n
+  };
+}
+export {
+  R as clamp,
+  E as createCoords,
+  T as evaluate,
+  w as expandPaddingObject,
+  L as floor,
+  a as getAlignment,
+  y as getAlignmentAxis,
+  k as getAlignmentSides,
+  d as getAxisLength,
+  q as getExpandedPlacements,
+  s as getOppositeAlignmentPlacement,
+  b as getOppositeAxis,
+  z as getOppositeAxisPlacements,
+  f as getOppositePlacement,
+  B as getPaddingObject,
+  g as getSide,
+  P as getSideAxis,
+  p as max,
+  m as min,
+  D as rectToClientRect,
+  C as round,
+  j as sides
+};

package/dist/index213.js

@@ -0,0 +1,47 @@
+import { evaluate as W, getPaddingObject as Y, getAlignmentAxis as k, getAlignment as q, clamp as B, getAxisLength as C } from "./index212.js";
+const F = (s) => ({
+  name: "arrow",
+  options: s,
+  async fn(i) {
+    const {
+      x: y,
+      y: j,
+      placement: x,
+      rects: n,
+      platform: f,
+      elements: l,
+      middlewareData: M
+    } = i, {
+      element: g,
+      padding: v = 0,
+      offsetParent: z = "real"
+    } = W(s, i) || {};
+    if (g == null)
+      return {};
+    const h = Y(v), m = {
+      x: y,
+      y: j
+    }, t = k(x), e = C(t), r = await f.getDimensions(g), d = t === "y", E = d ? "top" : "left", H = d ? "bottom" : "right", A = d ? "clientHeight" : "clientWidth", L = n.reference[e] + n.reference[t] - m[t] - n.floating[e], R = m[t] - n.reference[t], S = z === "real" ? await f.getOffsetParent?.(g) : l.floating;
+    let a = l.floating[A] || n.floating[e];
+    (!a || !await f.isElement?.(S)) && (a = l.floating[A] || n.floating[e]);
+    const T = L / 2 - R / 2, O = a / 2 - r[e] / 2 - 1, u = Math.min(h[E], O), b = Math.min(h[H], O), c = u, D = a - r[e] - b, o = a / 2 - r[e] / 2 + T, P = B(c, o, D), p = !M.arrow && q(x) != null && o !== P && n.reference[e] / 2 - (o < c ? u : b) - r[e] / 2 < 0, w = p ? o < c ? o - c : o - D : 0;
+    return {
+      [t]: m[t] + w,
+      data: {
+        [t]: P,
+        centerOffset: o - P - w,
+        ...p && {
+          alignmentOffset: w
+        }
+      },
+      reset: p
+    };
+  }
+}), I = (s, i) => ({
+  ...F(s),
+  options: [s, i]
+});
+export {
+  I as arrow,
+  F as baseArrow
+};

package/dist/index214.js

@@ -0,0 +1,20 @@
+import { hide as a } from "./index216.js";
+const o = {
+  name: "hide",
+  async fn(e) {
+    const {
+      width: n,
+      height: d,
+      x: i,
+      y: t
+    } = e.rects.reference, r = n === 0 && d === 0 && i === 0 && t === 0;
+    return {
+      data: {
+        referenceHidden: (await a().fn(e)).data?.referenceHidden || r
+      }
+    };
+  }
+};
+export {
+  o as hide
+};

package/dist/index215.js

@@ -0,0 +1,7 @@
+const e = {
+  sideX: "left",
+  sideY: "top"
+};
+export {
+  e as DEFAULT_SIDES
+};

package/dist/index216.js

@@ -0,0 +1,183 @@
+import { flip as H, offset as I, size as J, hide as K, computePosition as N, shift as Q, limitShift as T } from "./index218.js";
+import { autoUpdate as ae, platform as de } from "./index218.js";
+import * as r from "react";
+import { useLayoutEffect as X } from "react";
+import * as Y from "react-dom";
+var Z = typeof document < "u", b = function() {
+}, R = Z ? X : b;
+function w(e, t) {
+  if (e === t)
+    return !0;
+  if (typeof e != typeof t)
+    return !1;
+  if (typeof e == "function" && e.toString() === t.toString())
+    return !0;
+  let n, f, c;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (n = e.length, n !== t.length) return !1;
+      for (f = n; f-- !== 0; )
+        if (!w(e[f], t[f]))
+          return !1;
+      return !0;
+    }
+    if (c = Object.keys(e), n = c.length, n !== Object.keys(t).length)
+      return !1;
+    for (f = n; f-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, c[f]))
+        return !1;
+    for (f = n; f-- !== 0; ) {
+      const p = c[f];
+      if (!(p === "_owner" && e.$$typeof) && !w(e[p], t[p]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function L(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function z(e, t) {
+  const n = L(e);
+  return Math.round(t * n) / n;
+}
+function k(e) {
+  const t = r.useRef(e);
+  return R(() => {
+    t.current = e;
+  }), t;
+}
+function ne(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: f = [],
+    platform: c,
+    elements: {
+      reference: p,
+      floating: A
+    } = {},
+    transform: D = !0,
+    whileElementsMounted: E,
+    open: x
+  } = e, [s, C] = r.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [M, q] = r.useState(f);
+  w(M, f) || q(f);
+  const [B, U] = r.useState(null), [V, W] = r.useState(null), _ = r.useCallback((o) => {
+    o !== a.current && (a.current = o, U(o));
+  }, []), v = r.useCallback((o) => {
+    o !== d.current && (d.current = o, W(o));
+  }, []), i = p || B, u = A || V, a = r.useRef(null), d = r.useRef(null), y = r.useRef(s), G = E != null, S = k(E), P = k(c), F = k(x), g = r.useCallback(() => {
+    if (!a.current || !d.current)
+      return;
+    const o = {
+      placement: t,
+      strategy: n,
+      middleware: M
+    };
+    P.current && (o.platform = P.current), N(a.current, d.current, o).then((h) => {
+      const m = {
+        ...h,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: F.current !== !1
+      };
+      $.current && !w(y.current, m) && (y.current = m, Y.flushSync(() => {
+        C(m);
+      }));
+    });
+  }, [M, t, n, P, F]);
+  R(() => {
+    x === !1 && y.current.isPositioned && (y.current.isPositioned = !1, C((o) => ({
+      ...o,
+      isPositioned: !1
+    })));
+  }, [x]);
+  const $ = r.useRef(!1);
+  R(() => ($.current = !0, () => {
+    $.current = !1;
+  }), []), R(() => {
+    if (i && (a.current = i), u && (d.current = u), i && u) {
+      if (S.current)
+        return S.current(i, u, g);
+      g();
+    }
+  }, [i, u, g, S, G]);
+  const O = r.useMemo(() => ({
+    reference: a,
+    floating: d,
+    setReference: _,
+    setFloating: v
+  }), [_, v]), l = r.useMemo(() => ({
+    reference: i,
+    floating: u
+  }), [i, u]), j = r.useMemo(() => {
+    const o = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!l.floating)
+      return o;
+    const h = z(l.floating, s.x), m = z(l.floating, s.y);
+    return D ? {
+      ...o,
+      transform: "translate(" + h + "px, " + m + "px)",
+      ...L(l.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: h,
+      top: m
+    };
+  }, [n, D, l.floating, s.x, s.y]);
+  return r.useMemo(() => ({
+    ...s,
+    update: g,
+    refs: O,
+    elements: l,
+    floatingStyles: j
+  }), [s, g, O, l, j]);
+}
+const re = (e, t) => ({
+  ...I(e),
+  options: [e, t]
+}), oe = (e, t) => ({
+  ...Q(e),
+  options: [e, t]
+}), fe = (e, t) => ({
+  ...T(e),
+  options: [e, t]
+}), se = (e, t) => ({
+  ...H(e),
+  options: [e, t]
+}), ie = (e, t) => ({
+  ...J(e),
+  options: [e, t]
+}), ue = (e, t) => ({
+  ...K(e),
+  options: [e, t]
+});
+export {
+  ae as autoUpdate,
+  N as computePosition,
+  se as flip,
+  ue as hide,
+  fe as limitShift,
+  re as offset,
+  de as platform,
+  oe as shift,
+  ie as size,
+  ne as useFloating
+};

package/dist/index217.js

@@ -0,0 +1,78 @@
+import * as o from "react";
+import { useFloating as P } from "./index216.js";
+import { isElement as s } from "./index101.js";
+import { useIsoLayoutEffect as F } from "./index104.js";
+import { useFloatingTree as V } from "./index181.js";
+import { useFloatingRootContext as v } from "./index145.js";
+function w(c = {}) {
+  const {
+    nodeId: m,
+    externalTree: y
+  } = c, I = v(c), t = c.rootContext || I, r = {
+    reference: t.useState("referenceElement"),
+    floating: t.useState("floatingElement"),
+    domReference: t.useState("domReferenceElement")
+  }, [g, M] = o.useState(null), i = o.useRef(null), b = V(y);
+  F(() => {
+    r.domReference && (i.current = r.domReference);
+  }, [r.domReference]);
+  const n = P({
+    ...c,
+    elements: {
+      ...r,
+      ...g && {
+        reference: g
+      }
+    }
+  }), d = o.useCallback((e) => {
+    const u = s(e) ? {
+      getBoundingClientRect: () => e.getBoundingClientRect(),
+      getClientRects: () => e.getClientRects(),
+      contextElement: e
+    } : e;
+    M(u), n.refs.setReference(u);
+  }, [n.refs]), [R, S] = o.useState(null), [k, L] = o.useState(null);
+  t.useSyncedValue("referenceElement", R), t.useSyncedValue("domReferenceElement", s(R) ? R : null), t.useSyncedValue("floatingElement", k);
+  const x = o.useCallback((e) => {
+    (s(e) || e === null) && (i.current = e, S(e)), (s(n.refs.reference.current) || n.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    // `null` to support `positionReference` + an unstable `reference`
+    // callback ref.
+    e !== null && !s(e)) && n.refs.setReference(e);
+  }, [n.refs, S]), C = o.useCallback((e) => {
+    L(e), n.refs.setFloating(e);
+  }, [n.refs]), l = o.useMemo(() => ({
+    ...n.refs,
+    setReference: x,
+    setFloating: C,
+    setPositionReference: d,
+    domReference: i
+  }), [n.refs, x, C, d]), f = o.useMemo(() => ({
+    ...n.elements,
+    domReference: r.domReference
+  }), [n.elements, r.domReference]), E = t.useState("open"), p = t.useState("floatingId"), a = o.useMemo(() => ({
+    ...n,
+    dataRef: t.context.dataRef,
+    open: E,
+    onOpenChange: t.setOpen,
+    events: t.context.events,
+    floatingId: p,
+    refs: l,
+    elements: f,
+    nodeId: m,
+    rootStore: t
+  }), [n, l, f, m, t, E, p]);
+  return F(() => {
+    t.context.dataRef.current.floatingContext = a;
+    const e = b?.nodesRef.current.find((u) => u.id === m);
+    e && (e.context = a);
+  }), o.useMemo(() => ({
+    ...n,
+    context: a,
+    refs: l,
+    elements: f,
+    rootStore: t
+  }), [n, l, f, a, t]);
+}
+export {
+  w as useFloating
+};