kiban-design-system 3.8.0 → 3.10.0

package/dist/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js

@@ -0,0 +1,136 @@
+function c() {
+  return typeof window < "u";
+}
+function u(t) {
+  return p(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function i(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function N(t) {
+  var e;
+  return (e = (p(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function p(t) {
+  return c() ? t instanceof Node || t instanceof i(t).Node : !1;
+}
+function m(t) {
+  return c() ? t instanceof Element || t instanceof i(t).Element : !1;
+}
+function w(t) {
+  return c() ? t instanceof HTMLElement || t instanceof i(t).HTMLElement : !1;
+}
+function f(t) {
+  return !c() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof i(t).ShadowRoot;
+}
+const E = /* @__PURE__ */ new Set(["inline", "contents"]);
+function y(t) {
+  const {
+    overflow: e,
+    overflowX: n,
+    overflowY: o,
+    display: r
+  } = S(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + o + n) && !E.has(r);
+}
+const T = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function A(t) {
+  return T.has(u(t));
+}
+const v = [":popover-open", ":modal"];
+function L(t) {
+  return v.some((e) => {
+    try {
+      return t.matches(e);
+    } catch {
+      return !1;
+    }
+  });
+}
+const D = ["transform", "translate", "scale", "rotate", "perspective"], C = ["transform", "translate", "scale", "rotate", "perspective", "filter"], k = ["paint", "layout", "strict", "content"];
+function V(t) {
+  const e = O(), n = m(t) ? S(t) : t;
+  return D.some((o) => n[o] ? n[o] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !e && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !e && (n.filter ? n.filter !== "none" : !1) || C.some((o) => (n.willChange || "").includes(o)) || k.some((o) => (n.contain || "").includes(o));
+}
+function B(t) {
+  let e = s(t);
+  for (; w(e) && !h(e); ) {
+    if (V(e))
+      return e;
+    if (L(e))
+      return null;
+    e = s(e);
+  }
+  return null;
+}
+function O() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+const R = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function h(t) {
+  return R.has(u(t));
+}
+function S(t) {
+  return i(t).getComputedStyle(t);
+}
+function F(t) {
+  return m(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function s(t) {
+  if (u(t) === "html")
+    return t;
+  const e = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    f(t) && t.host || // Fallback.
+    N(t)
+  );
+  return f(e) ? e.host : e;
+}
+function b(t) {
+  const e = s(t);
+  return h(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : w(e) && y(e) ? e : b(e);
+}
+function d(t, e, n) {
+  var o;
+  e === void 0 && (e = []), n === void 0 && (n = !0);
+  const r = b(t), g = r === ((o = t.ownerDocument) == null ? void 0 : o.body), l = i(r);
+  if (g) {
+    const a = _(l);
+    return e.concat(l, l.visualViewport || [], y(r) ? r : [], a && n ? d(a) : []);
+  }
+  return e.concat(r, d(r, [], n));
+}
+function _(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+export {
+  S as getComputedStyle,
+  B as getContainingBlock,
+  N as getDocumentElement,
+  _ as getFrameElement,
+  b as getNearestOverflowAncestor,
+  u as getNodeName,
+  F as getNodeScroll,
+  d as getOverflowAncestors,
+  s as getParentNode,
+  i as getWindow,
+  V as isContainingBlock,
+  m as isElement,
+  w as isHTMLElement,
+  h as isLastTraversableNode,
+  p as isNode,
+  y as isOverflowElement,
+  f as isShadowRoot,
+  A as isTableElement,
+  L as isTopLayer,
+  O as isWebKit
+};

package/dist/node_modules/@floating-ui/utils/dist/floating-ui.utils.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/node_modules/@radix-ui/primitive/dist/index.js

@@ -0,0 +1,9 @@
+function f(n, r, { checkForDefaultPrevented: t = !0 } = {}) {
+  return function(e) {
+    if (n?.(e), t === !1 || !e.defaultPrevented)
+      return r?.(e);
+  };
+}
+export {
+  f as composeEventHandlers
+};

package/dist/node_modules/@radix-ui/react-arrow/dist/index.js

@@ -0,0 +1,24 @@
+import * as n from "react";
+import { Primitive as p } from "../../react-primitive/dist/index.js";
+import { jsx as o } from "react/jsx-runtime";
+var v = "Arrow", e = n.forwardRef((r, i) => {
+  const { children: t, width: a = 10, height: s = 5, ...m } = r;
+  return /* @__PURE__ */ o(
+    p.svg,
+    {
+      ...m,
+      ref: i,
+      width: a,
+      height: s,
+      viewBox: "0 0 30 10",
+      preserveAspectRatio: "none",
+      children: r.asChild ? t : /* @__PURE__ */ o("polygon", { points: "0,0 30,0 15,10" })
+    }
+  );
+});
+e.displayName = v;
+var h = e;
+export {
+  e as Arrow,
+  h as Root
+};

package/dist/node_modules/@radix-ui/react-collection/dist/index.js

@@ -0,0 +1,50 @@
+import r from "react";
+import { createContextScope as y } from "../../react-context/dist/index.js";
+import { useComposedRefs as M } from "../../react-compose-refs/dist/index.js";
+import { createSlot as x } from "@radix-ui/react-slot";
+import { jsx as u } from "react/jsx-runtime";
+function g(s) {
+  const m = s + "CollectionProvider", [A, N] = y(m), [_, f] = A(
+    m,
+    { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }
+  ), p = (c) => {
+    const { scope: e, children: l } = c, o = r.useRef(null), t = r.useRef(/* @__PURE__ */ new Map()).current;
+    return /* @__PURE__ */ u(_, { scope: e, itemMap: t, collectionRef: o, children: l });
+  };
+  p.displayName = m;
+  const a = s + "CollectionSlot", E = x(a), C = r.forwardRef(
+    (c, e) => {
+      const { scope: l, children: o } = c, t = f(a, l), n = M(e, t.collectionRef);
+      return /* @__PURE__ */ u(E, { ref: n, children: o });
+    }
+  );
+  C.displayName = a;
+  const d = s + "CollectionItemSlot", R = "data-radix-collection-item", T = x(d), I = r.forwardRef(
+    (c, e) => {
+      const { scope: l, children: o, ...t } = c, n = r.useRef(null), S = M(e, n), i = f(d, l);
+      return r.useEffect(() => (i.itemMap.set(n, { ref: n, ...t }), () => {
+        i.itemMap.delete(n);
+      })), /* @__PURE__ */ u(T, { [R]: "", ref: S, children: o });
+    }
+  );
+  I.displayName = d;
+  function O(c) {
+    const e = f(s + "CollectionConsumer", c);
+    return r.useCallback(() => {
+      const o = e.collectionRef.current;
+      if (!o) return [];
+      const t = Array.from(o.querySelectorAll(`[${R}]`));
+      return Array.from(e.itemMap.values()).sort(
+        (i, v) => t.indexOf(i.ref.current) - t.indexOf(v.ref.current)
+      );
+    }, [e.collectionRef, e.itemMap]);
+  }
+  return [
+    { Provider: p, Slot: C, ItemSlot: I },
+    O,
+    N
+  ];
+}
+export {
+  g as createCollection
+};

package/dist/node_modules/@radix-ui/react-compose-refs/dist/index.js

@@ -0,0 +1,29 @@
+import * as f from "react";
+function l(n, o) {
+  if (typeof n == "function")
+    return n(o);
+  n != null && (n.current = o);
+}
+function i(...n) {
+  return (o) => {
+    let u = !1;
+    const c = n.map((t) => {
+      const e = l(t, o);
+      return !u && typeof e == "function" && (u = !0), e;
+    });
+    if (u)
+      return () => {
+        for (let t = 0; t < c.length; t++) {
+          const e = c[t];
+          typeof e == "function" ? e() : l(n[t], null);
+        }
+      };
+  };
+}
+function s(...n) {
+  return f.useCallback(i(...n), n);
+}
+export {
+  i as composeRefs,
+  s as useComposedRefs
+};

package/dist/node_modules/@radix-ui/react-context/dist/index.js

@@ -0,0 +1,53 @@
+import * as u from "react";
+import { jsx as _ } from "react/jsx-runtime";
+function P(e, p = []) {
+  let n = [];
+  function m(s, t) {
+    const o = u.createContext(t), c = n.length;
+    n = [...n, t];
+    const a = (i) => {
+      const { scope: f, children: C, ...x } = i, d = f?.[e]?.[c] || o, v = u.useMemo(() => x, Object.values(x));
+      return /* @__PURE__ */ _(d.Provider, { value: v, children: C });
+    };
+    a.displayName = s + "Provider";
+    function S(i, f) {
+      const C = f?.[e]?.[c] || o, x = u.useContext(C);
+      if (x) return x;
+      if (t !== void 0) return t;
+      throw new Error(`\`${i}\` must be used within \`${s}\``);
+    }
+    return [a, S];
+  }
+  const r = () => {
+    const s = n.map((t) => u.createContext(t));
+    return function(o) {
+      const c = o?.[e] || s;
+      return u.useMemo(
+        () => ({ [`__scope${e}`]: { ...o, [e]: c } }),
+        [o, c]
+      );
+    };
+  };
+  return r.scopeName = e, [m, h(r, ...p)];
+}
+function h(...e) {
+  const p = e[0];
+  if (e.length === 1) return p;
+  const n = () => {
+    const m = e.map((r) => ({
+      useScope: r(),
+      scopeName: r.scopeName
+    }));
+    return function(s) {
+      const t = m.reduce((o, { useScope: c, scopeName: a }) => {
+        const i = c(s)[`__scope${a}`];
+        return { ...o, ...i };
+      }, {});
+      return u.useMemo(() => ({ [`__scope${p.scopeName}`]: t }), [t]);
+    };
+  };
+  return n.scopeName = p.scopeName, n;
+}
+export {
+  P as createContextScope
+};

package/dist/node_modules/@radix-ui/react-direction/dist/index.js

@@ -0,0 +1,10 @@
+import * as t from "react";
+import "react/jsx-runtime";
+var r = t.createContext(void 0);
+function n(o) {
+  const e = t.useContext(r);
+  return o || e || "ltr";
+}
+export {
+  n as useDirection
+};

package/dist/node_modules/@radix-ui/react-dismissable-layer/dist/index.js

@@ -0,0 +1,127 @@
+import * as n from "react";
+import { composeEventHandlers as h } from "../../primitive/dist/index.js";
+import { Primitive as w, dispatchDiscreteCustomEvent as k } from "../../react-primitive/dist/index.js";
+import { useComposedRefs as g } from "../../react-compose-refs/dist/index.js";
+import { useCallbackRef as R } from "../../react-use-callback-ref/dist/index.js";
+import { useEscapeKeydown as U } from "../../react-use-escape-keydown/dist/index.js";
+import { jsx as T } from "react/jsx-runtime";
+var z = "DismissableLayer", y = "dismissableLayer.update", H = "dismissableLayer.pointerDownOutside", M = "dismissableLayer.focusOutside", C, B = n.createContext({
+  layers: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  branches: /* @__PURE__ */ new Set()
+}), K = n.forwardRef(
+  (s, e) => {
+    const {
+      disableOutsidePointerEvents: r = !1,
+      onEscapeKeyDown: a,
+      onPointerDownOutside: i,
+      onFocusOutside: c,
+      onInteractOutside: f,
+      onDismiss: d,
+      ...E
+    } = s, o = n.useContext(B), [u, F] = n.useState(null), l = u?.ownerDocument ?? globalThis?.document, [, I] = n.useState({}), S = g(e, (t) => F(t)), p = Array.from(o.layers), [W] = [...o.layersWithOutsidePointerEventsDisabled].slice(-1), A = p.indexOf(W), b = u ? p.indexOf(u) : -1, N = o.layersWithOutsidePointerEventsDisabled.size > 0, D = b >= A, _ = Y((t) => {
+      const v = t.target, P = [...o.branches].some((m) => m.contains(v));
+      !D || P || (i?.(t), f?.(t), t.defaultPrevented || d?.());
+    }, l), O = q((t) => {
+      const v = t.target;
+      [...o.branches].some((m) => m.contains(v)) || (c?.(t), f?.(t), t.defaultPrevented || d?.());
+    }, l);
+    return U((t) => {
+      b === o.layers.size - 1 && (a?.(t), !t.defaultPrevented && d && (t.preventDefault(), d()));
+    }, l), n.useEffect(() => {
+      if (u)
+        return r && (o.layersWithOutsidePointerEventsDisabled.size === 0 && (C = l.body.style.pointerEvents, l.body.style.pointerEvents = "none"), o.layersWithOutsidePointerEventsDisabled.add(u)), o.layers.add(u), L(), () => {
+          r && o.layersWithOutsidePointerEventsDisabled.size === 1 && (l.body.style.pointerEvents = C);
+        };
+    }, [u, l, r, o]), n.useEffect(() => () => {
+      u && (o.layers.delete(u), o.layersWithOutsidePointerEventsDisabled.delete(u), L());
+    }, [u, o]), n.useEffect(() => {
+      const t = () => I({});
+      return document.addEventListener(y, t), () => document.removeEventListener(y, t);
+    }, []), /* @__PURE__ */ T(
+      w.div,
+      {
+        ...E,
+        ref: S,
+        style: {
+          pointerEvents: N ? D ? "auto" : "none" : void 0,
+          ...s.style
+        },
+        onFocusCapture: h(s.onFocusCapture, O.onFocusCapture),
+        onBlurCapture: h(s.onBlurCapture, O.onBlurCapture),
+        onPointerDownCapture: h(
+          s.onPointerDownCapture,
+          _.onPointerDownCapture
+        )
+      }
+    );
+  }
+);
+K.displayName = z;
+var j = "DismissableLayerBranch", X = n.forwardRef((s, e) => {
+  const r = n.useContext(B), a = n.useRef(null), i = g(e, a);
+  return n.useEffect(() => {
+    const c = a.current;
+    if (c)
+      return r.branches.add(c), () => {
+        r.branches.delete(c);
+      };
+  }, [r.branches]), /* @__PURE__ */ T(w.div, { ...s, ref: i });
+});
+X.displayName = j;
+function Y(s, e = globalThis?.document) {
+  const r = R(s), a = n.useRef(!1), i = n.useRef(() => {
+  });
+  return n.useEffect(() => {
+    const c = (d) => {
+      if (d.target && !a.current) {
+        let E = function() {
+          x(
+            H,
+            r,
+            o,
+            { discrete: !0 }
+          );
+        };
+        const o = { originalEvent: d };
+        d.pointerType === "touch" ? (e.removeEventListener("click", i.current), i.current = E, e.addEventListener("click", i.current, { once: !0 })) : E();
+      } else
+        e.removeEventListener("click", i.current);
+      a.current = !1;
+    }, f = window.setTimeout(() => {
+      e.addEventListener("pointerdown", c);
+    }, 0);
+    return () => {
+      window.clearTimeout(f), e.removeEventListener("pointerdown", c), e.removeEventListener("click", i.current);
+    };
+  }, [e, r]), {
+    // ensures we check React component tree (not just DOM tree)
+    onPointerDownCapture: () => a.current = !0
+  };
+}
+function q(s, e = globalThis?.document) {
+  const r = R(s), a = n.useRef(!1);
+  return n.useEffect(() => {
+    const i = (c) => {
+      c.target && !a.current && x(M, r, { originalEvent: c }, {
+        discrete: !1
+      });
+    };
+    return e.addEventListener("focusin", i), () => e.removeEventListener("focusin", i);
+  }, [e, r]), {
+    onFocusCapture: () => a.current = !0,
+    onBlurCapture: () => a.current = !1
+  };
+}
+function L() {
+  const s = new CustomEvent(y);
+  document.dispatchEvent(s);
+}
+function x(s, e, r, { discrete: a }) {
+  const i = r.originalEvent.target, c = new CustomEvent(s, { bubbles: !1, cancelable: !0, detail: r });
+  e && i.addEventListener(s, e, { once: !0 }), a ? k(i, c) : i.dispatchEvent(c);
+}
+export {
+  K as DismissableLayer,
+  X as DismissableLayerBranch
+};