@dmsi/wedgekit-react 2.0.0 → 2.0.1

package/dist/node_modules/@dnd-kit/modifiers/dist/modifiers.esm.js

@@ -0,0 +1,13 @@
+import "react";
+const e = (r) => {
+  let {
+    transform: t
+  } = r;
+  return {
+    ...t,
+    y: 0
+  };
+};
+export {
+  e as restrictToHorizontalAxis
+};

package/dist/node_modules/@dnd-kit/sortable/dist/sortable.esm.js

@@ -0,0 +1,367 @@
+import H, { useMemo as E, useRef as P, useEffect as L, useContext as ue, useState as fe } from "react";
+import { KeyboardCode as O, useDndContext as ge, useDroppable as pe, useDraggable as ve, getClientRect as be } from "../../core/dist/core.esm.js";
+import { useUniqueId as me, useIsomorphicLayoutEffect as K, useCombinedRefs as Ie, isKeyboardEvent as xe, CSS as U } from "../../utilities/dist/utilities.esm.js";
+function V(e, n, t) {
+  const r = e.slice();
+  return r.splice(t < 0 ? r.length + t : t, 0, r.splice(n, 1)[0]), r;
+}
+function he(e, n) {
+  return e.reduce((t, r, i) => {
+    const s = n.get(r);
+    return s && (t[i] = s), t;
+  }, Array(e.length));
+}
+function N(e) {
+  return e !== null && e >= 0;
+}
+function ye(e, n) {
+  if (e === n)
+    return !0;
+  if (e.length !== n.length)
+    return !1;
+  for (let t = 0; t < e.length; t++)
+    if (e[t] !== n[t])
+      return !1;
+  return !0;
+}
+function Re(e) {
+  return typeof e == "boolean" ? {
+    draggable: e,
+    droppable: e
+  } : e;
+}
+const A = {
+  scaleX: 1,
+  scaleY: 1
+}, Pe = (e) => {
+  var n;
+  let {
+    rects: t,
+    activeNodeRect: r,
+    activeIndex: i,
+    overIndex: s,
+    index: o
+  } = e;
+  const a = (n = t[i]) != null ? n : r;
+  if (!a)
+    return null;
+  const u = we(t, o, i);
+  if (o === i) {
+    const l = t[s];
+    return l ? {
+      x: i < s ? l.left + l.width - (a.left + a.width) : l.left - a.left,
+      y: 0,
+      ...A
+    } : null;
+  }
+  return o > i && o <= s ? {
+    x: -a.width - u,
+    y: 0,
+    ...A
+  } : o < i && o >= s ? {
+    x: a.width + u,
+    y: 0,
+    ...A
+  } : {
+    x: 0,
+    y: 0,
+    ...A
+  };
+};
+function we(e, n, t) {
+  const r = e[n], i = e[n - 1], s = e[n + 1];
+  return !r || !i && !s ? 0 : t < n ? i ? r.left - (i.left + i.width) : s.left - (r.left + r.width) : s ? s.left - (r.left + r.width) : r.left - (i.left + i.width);
+}
+const j = (e) => {
+  let {
+    rects: n,
+    activeIndex: t,
+    overIndex: r,
+    index: i
+  } = e;
+  const s = V(n, r, t), o = n[i], a = s[i];
+  return !a || !o ? null : {
+    x: a.left - o.left,
+    y: a.top - o.top,
+    scaleX: a.width / o.width,
+    scaleY: a.height / o.height
+  };
+}, k = "Sortable", J = /* @__PURE__ */ H.createContext({
+  activeIndex: -1,
+  containerId: k,
+  disableTransforms: !1,
+  items: [],
+  overIndex: -1,
+  useDragOverlay: !1,
+  sortedRects: [],
+  strategy: j,
+  disabled: {
+    draggable: !1,
+    droppable: !1
+  }
+});
+function Xe(e) {
+  let {
+    children: n,
+    id: t,
+    items: r,
+    strategy: i = j,
+    disabled: s = !1
+  } = e;
+  const {
+    active: o,
+    dragOverlay: a,
+    droppableRects: u,
+    over: l,
+    measureDroppableContainers: c
+  } = ge(), p = me(k, t), b = a.rect !== null, f = E(() => r.map((m) => typeof m == "object" && "id" in m ? m.id : m), [r]), C = o != null, h = o ? f.indexOf(o.id) : -1, v = l ? f.indexOf(l.id) : -1, T = P(f), y = !ye(f, T.current), R = v !== -1 && h === -1 || y, g = Re(s);
+  K(() => {
+    y && C && c(f);
+  }, [y, f, C, c]), L(() => {
+    T.current = f;
+  }, [f]);
+  const w = E(
+    () => ({
+      activeIndex: h,
+      containerId: p,
+      disabled: g,
+      disableTransforms: R,
+      items: f,
+      overIndex: v,
+      useDragOverlay: b,
+      sortedRects: he(f, u),
+      strategy: i
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [h, p, g.draggable, g.droppable, R, f, v, u, b, i]
+  );
+  return H.createElement(J.Provider, {
+    value: w
+  }, n);
+}
+const De = (e) => {
+  let {
+    id: n,
+    items: t,
+    activeIndex: r,
+    overIndex: i
+  } = e;
+  return V(t, r, i).indexOf(n);
+}, Se = (e) => {
+  let {
+    containerId: n,
+    isSorting: t,
+    wasDragging: r,
+    index: i,
+    items: s,
+    newIndex: o,
+    previousItems: a,
+    previousContainerId: u,
+    transition: l
+  } = e;
+  return !l || !r || a !== s && i === o ? !1 : t ? !0 : o !== i && n === u;
+}, Ce = {
+  duration: 200,
+  easing: "ease"
+}, Q = "transform", Te = /* @__PURE__ */ U.Transition.toString({
+  property: Q,
+  duration: 0,
+  easing: "linear"
+}), Oe = {
+  roleDescription: "sortable"
+};
+function Ne(e) {
+  let {
+    disabled: n,
+    index: t,
+    node: r,
+    rect: i
+  } = e;
+  const [s, o] = fe(null), a = P(t);
+  return K(() => {
+    if (!n && t !== a.current && r.current) {
+      const u = i.current;
+      if (u) {
+        const l = be(r.current, {
+          ignoreTransform: !0
+        }), c = {
+          x: u.left - l.left,
+          y: u.top - l.top,
+          scaleX: u.width / l.width,
+          scaleY: u.height / l.height
+        };
+        (c.x || c.y) && o(c);
+      }
+    }
+    t !== a.current && (a.current = t);
+  }, [n, t, r, i]), L(() => {
+    s && o(null);
+  }, [s]), s;
+}
+function Ge(e) {
+  let {
+    animateLayoutChanges: n = Se,
+    attributes: t,
+    disabled: r,
+    data: i,
+    getNewIndex: s = De,
+    id: o,
+    strategy: a,
+    resizeObserverConfig: u,
+    transition: l = Ce
+  } = e;
+  const {
+    items: c,
+    containerId: p,
+    activeIndex: b,
+    disabled: f,
+    disableTransforms: C,
+    sortedRects: h,
+    overIndex: v,
+    useDragOverlay: T,
+    strategy: y
+  } = ue(J), R = Ae(r, f), g = c.indexOf(o), w = E(() => ({
+    sortable: {
+      containerId: p,
+      index: g,
+      items: c
+    },
+    ...i
+  }), [p, i, g, c]), m = E(() => c.slice(c.indexOf(o)), [c, o]), {
+    rect: X,
+    node: G,
+    isOver: W,
+    setNodeRef: M
+  } = pe({
+    id: o,
+    data: w,
+    disabled: R.droppable,
+    resizeObserverConfig: {
+      updateMeasurementsFor: m,
+      ...u
+    }
+  }), {
+    active: D,
+    activatorEvent: Z,
+    activeNodeRect: ee,
+    attributes: te,
+    setNodeRef: Y,
+    listeners: re,
+    isDragging: _,
+    over: ne,
+    setActivatorNodeRef: ie,
+    transform: oe
+  } = ve({
+    id: o,
+    data: w,
+    attributes: {
+      ...Oe,
+      ...t
+    },
+    disabled: R.draggable
+  }), se = Ie(M, Y), I = !!D, $ = I && !C && N(b) && N(v), q = !T && _, B = q && $ ? oe : null, ae = $ ? B ?? (a ?? y)({
+    rects: h,
+    activeNodeRect: ee,
+    activeIndex: b,
+    overIndex: v,
+    index: g
+  }) : null, S = N(b) && N(v) ? s({
+    id: o,
+    items: c,
+    activeIndex: b,
+    overIndex: v
+  }) : g, x = D?.id, d = P({
+    activeId: x,
+    items: c,
+    newIndex: S,
+    containerId: p
+  }), ce = c !== d.current.items, F = n({
+    active: D,
+    containerId: p,
+    isDragging: _,
+    isSorting: I,
+    id: o,
+    index: g,
+    items: c,
+    newIndex: d.current.newIndex,
+    previousItems: d.current.items,
+    previousContainerId: d.current.containerId,
+    transition: l,
+    wasDragging: d.current.activeId != null
+  }), z = Ne({
+    disabled: !F,
+    index: g,
+    node: G,
+    rect: X
+  });
+  return L(() => {
+    I && d.current.newIndex !== S && (d.current.newIndex = S), p !== d.current.containerId && (d.current.containerId = p), c !== d.current.items && (d.current.items = c);
+  }, [I, S, p, c]), L(() => {
+    if (x === d.current.activeId)
+      return;
+    if (x != null && d.current.activeId == null) {
+      d.current.activeId = x;
+      return;
+    }
+    const de = setTimeout(() => {
+      d.current.activeId = x;
+    }, 50);
+    return () => clearTimeout(de);
+  }, [x]), {
+    active: D,
+    activeIndex: b,
+    attributes: te,
+    data: w,
+    rect: X,
+    index: g,
+    newIndex: S,
+    items: c,
+    isOver: W,
+    isSorting: I,
+    isDragging: _,
+    listeners: re,
+    node: G,
+    overIndex: v,
+    over: ne,
+    setNodeRef: se,
+    setActivatorNodeRef: ie,
+    setDroppableNodeRef: M,
+    setDraggableNodeRef: Y,
+    transform: z ?? ae,
+    transition: le()
+  };
+  function le() {
+    if (
+      // Temporarily disable transitions for a single frame to set up derived transforms
+      z || // Or to prevent items jumping to back to their "new" position when items change
+      ce && d.current.newIndex === g
+    )
+      return Te;
+    if (!(q && !xe(Z) || !l) && (I || F))
+      return U.Transition.toString({
+        ...l,
+        property: Q
+      });
+  }
+}
+function Ae(e, n) {
+  var t, r;
+  return typeof e == "boolean" ? {
+    draggable: e,
+    // Backwards compatibility
+    droppable: !1
+  } : {
+    draggable: (t = e?.draggable) != null ? t : n.draggable,
+    droppable: (r = e?.droppable) != null ? r : n.droppable
+  };
+}
+O.Down, O.Right, O.Up, O.Left;
+export {
+  Xe as SortableContext,
+  V as arrayMove,
+  Se as defaultAnimateLayoutChanges,
+  De as defaultNewIndexGetter,
+  Pe as horizontalListSortingStrategy,
+  j as rectSortingStrategy,
+  Ge as useSortable
+};

package/dist/node_modules/@dnd-kit/utilities/dist/utilities.esm.js

@@ -0,0 +1,235 @@
+import { useRef as o, useMemo as l, useLayoutEffect as R, useEffect as g, useCallback as i } from "react";
+function Y() {
+  for (var n = arguments.length, t = new Array(n), e = 0; e < n; e++)
+    t[e] = arguments[e];
+  return l(
+    () => (u) => {
+      t.forEach((r) => r(u));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  );
+}
+const D = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u";
+function a(n) {
+  const t = Object.prototype.toString.call(n);
+  return t === "[object Window]" || // In Electron context the Window object serializes to [object global]
+  t === "[object global]";
+}
+function b(n) {
+  return "nodeType" in n;
+}
+function c(n) {
+  var t, e;
+  return n ? a(n) ? n : b(n) && (t = (e = n.ownerDocument) == null ? void 0 : e.defaultView) != null ? t : window : window;
+}
+function j(n) {
+  const {
+    Document: t
+  } = c(n);
+  return n instanceof t;
+}
+function C(n) {
+  return a(n) ? !1 : n instanceof c(n).HTMLElement;
+}
+function L(n) {
+  return n instanceof c(n).SVGElement;
+}
+function x(n) {
+  return n ? a(n) ? n.document : b(n) ? j(n) ? n : C(n) || L(n) ? n.ownerDocument : document : document : document;
+}
+const E = D ? R : g;
+function M(n) {
+  const t = o(n);
+  return E(() => {
+    t.current = n;
+  }), i(function() {
+    for (var e = arguments.length, u = new Array(e), r = 0; r < e; r++)
+      u[r] = arguments[r];
+    return t.current == null ? void 0 : t.current(...u);
+  }, []);
+}
+function A() {
+  const n = o(null), t = i((u, r) => {
+    n.current = setInterval(u, r);
+  }, []), e = i(() => {
+    n.current !== null && (clearInterval(n.current), n.current = null);
+  }, []);
+  return [t, e];
+}
+function I(n, t) {
+  t === void 0 && (t = [n]);
+  const e = o(n);
+  return E(() => {
+    e.current !== n && (e.current = n);
+  }, t), e;
+}
+function v(n, t) {
+  const e = o();
+  return l(
+    () => {
+      const u = n(e.current);
+      return e.current = u, u;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+function N(n) {
+  const t = M(n), e = o(null), u = i(
+    (r) => {
+      r !== e.current && t?.(r, e.current), e.current = r;
+    },
+    //eslint-disable-next-line
+    []
+  );
+  return [e, u];
+}
+function F(n) {
+  const t = o();
+  return g(() => {
+    t.current = n;
+  }, [n]), t.current;
+}
+let f = {};
+function H(n, t) {
+  return l(() => {
+    if (t)
+      return t;
+    const e = f[n] == null ? 0 : f[n] + 1;
+    return f[n] = e, n + "-" + e;
+  }, [n, t]);
+}
+function S(n) {
+  return function(t) {
+    for (var e = arguments.length, u = new Array(e > 1 ? e - 1 : 0), r = 1; r < e; r++)
+      u[r - 1] = arguments[r];
+    return u.reduce((s, T) => {
+      const y = Object.entries(T);
+      for (const [d, p] of y) {
+        const m = s[d];
+        m != null && (s[d] = m + n * p);
+      }
+      return s;
+    }, {
+      ...t
+    });
+  };
+}
+const W = /* @__PURE__ */ S(1), q = /* @__PURE__ */ S(-1);
+function O(n) {
+  return "clientX" in n && "clientY" in n;
+}
+function z(n) {
+  if (!n)
+    return !1;
+  const {
+    KeyboardEvent: t
+  } = c(n.target);
+  return t && n instanceof t;
+}
+function V(n) {
+  if (!n)
+    return !1;
+  const {
+    TouchEvent: t
+  } = c(n.target);
+  return t && n instanceof t;
+}
+function G(n) {
+  if (V(n)) {
+    if (n.touches && n.touches.length) {
+      const {
+        clientX: t,
+        clientY: e
+      } = n.touches[0];
+      return {
+        x: t,
+        y: e
+      };
+    } else if (n.changedTouches && n.changedTouches.length) {
+      const {
+        clientX: t,
+        clientY: e
+      } = n.changedTouches[0];
+      return {
+        x: t,
+        y: e
+      };
+    }
+  }
+  return O(n) ? {
+    x: n.clientX,
+    y: n.clientY
+  } : null;
+}
+const w = /* @__PURE__ */ Object.freeze({
+  Translate: {
+    toString(n) {
+      if (!n)
+        return;
+      const {
+        x: t,
+        y: e
+      } = n;
+      return "translate3d(" + (t ? Math.round(t) : 0) + "px, " + (e ? Math.round(e) : 0) + "px, 0)";
+    }
+  },
+  Scale: {
+    toString(n) {
+      if (!n)
+        return;
+      const {
+        scaleX: t,
+        scaleY: e
+      } = n;
+      return "scaleX(" + t + ") scaleY(" + e + ")";
+    }
+  },
+  Transform: {
+    toString(n) {
+      if (n)
+        return [w.Translate.toString(n), w.Scale.toString(n)].join(" ");
+    }
+  },
+  Transition: {
+    toString(n) {
+      let {
+        property: t,
+        duration: e,
+        easing: u
+      } = n;
+      return t + " " + e + "ms " + u;
+    }
+  }
+}), h = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function K(n) {
+  return n.matches(h) ? n : n.querySelector(h);
+}
+export {
+  w as CSS,
+  W as add,
+  D as canUseDOM,
+  K as findFirstFocusableNode,
+  G as getEventCoordinates,
+  x as getOwnerDocument,
+  c as getWindow,
+  O as hasViewportRelativeCoordinates,
+  j as isDocument,
+  C as isHTMLElement,
+  z as isKeyboardEvent,
+  b as isNode,
+  L as isSVGElement,
+  V as isTouchEvent,
+  a as isWindow,
+  q as subtract,
+  Y as useCombinedRefs,
+  M as useEvent,
+  A as useInterval,
+  E as useIsomorphicLayoutEffect,
+  I as useLatestValue,
+  v as useLazyMemo,
+  N as useNodeRef,
+  F as usePrevious,
+  H as useUniqueId
+};

package/dist/node_modules/@headlessui/react/dist/components/description/description.js

@@ -0,0 +1,45 @@
+"use client";
+import d, { useState as v, useMemo as p, useId as h, createContext as D, useContext as c } from "react";
+import { useEvent as g } from "../../hooks/use-event.js";
+import { useIsoMorphicEffect as E } from "../../hooks/use-iso-morphic-effect.js";
+import { useSlot as b } from "../../hooks/use-slot.js";
+import { useSyncRefs as x } from "../../hooks/use-sync-refs.js";
+import { useDisabled as S } from "../../internal/disabled.js";
+import { forwardRefWithAs as w, useRender as y } from "../../utils/render.js";
+let u = D(null);
+u.displayName = "DescriptionContext";
+function f() {
+  let t = c(u);
+  if (t === null) {
+    let e = new Error("You used a <Description /> component, but it is not inside a relevant parent.");
+    throw Error.captureStackTrace && Error.captureStackTrace(e, f), e;
+  }
+  return t;
+}
+function O() {
+  var t, e;
+  return (e = (t = c(u)) == null ? void 0 : t.value) != null ? e : void 0;
+}
+function Y() {
+  let [t, e] = v([]);
+  return [t.length > 0 ? t.join(" ") : void 0, p(() => function(r) {
+    let n = g((a) => (e((s) => [...s, a]), () => e((s) => {
+      let i = s.slice(), l = i.indexOf(a);
+      return l !== -1 && i.splice(l, 1), i;
+    }))), o = p(() => ({ register: n, slot: r.slot, name: r.name, props: r.props, value: r.value }), [n, r.slot, r.name, r.props, r.value]);
+    return d.createElement(u.Provider, { value: o }, r.children);
+  }, [e])];
+}
+let C = "p";
+function R(t, e) {
+  let r = h(), n = S(), { id: o = `headlessui-description-${r}`, ...a } = t, s = f(), i = x(e);
+  E(() => s.register(o), [o, s.register]);
+  let l = b({ ...s.slot, disabled: n || !1 }), m = { ref: i, ...s.props, id: o };
+  return y()({ ourProps: m, theirProps: a, slot: l, defaultTag: C, name: s.name || "Description" });
+}
+let $ = w(R), A = Object.assign($, {});
+export {
+  A as Description,
+  O as useDescribedBy,
+  Y as useDescriptions
+};

package/dist/node_modules/@headlessui/react/dist/components/keyboard.js

@@ -0,0 +1,4 @@
+var o = ((e) => (e.Space = " ", e.Enter = "Enter", e.Escape = "Escape", e.Backspace = "Backspace", e.Delete = "Delete", e.ArrowLeft = "ArrowLeft", e.ArrowUp = "ArrowUp", e.ArrowRight = "ArrowRight", e.ArrowDown = "ArrowDown", e.Home = "Home", e.End = "End", e.PageUp = "PageUp", e.PageDown = "PageDown", e.Tab = "Tab", e))(o || {});
+export {
+  o as Keys
+};