tttb 0.1.6

package/dist/index.js

@@ -0,0 +1,84 @@
+/* empty css                     */
+import * as t from "./components.js";
+import * as a from "./directives.js";
+import { dialog as p } from "./src/utils/dialog.js";
+import { localStorage as u } from "./src/utils/localStorage.js";
+import { msg as i } from "./src/utils/msg.js";
+import { chance as c, debounce as v, deepClone as g, getId as b, getRandomInt as h, getRandomStr as I, isMobile as T, isObject as P, isPromise as S, omit as j, pick as k, shuffleArray as y, throttleFirst as L } from "./src/utils/tools.js";
+import { default as O } from "./src/components/Button/index.js";
+import { default as C } from "./src/components/Checkbox/index.js";
+import { default as E } from "./src/components/Dialog/index.js";
+import { default as w } from "./src/components/Icon/index.js";
+import { default as A } from "./src/components/Loading/index.js";
+import { default as F } from "./src/components/Message/index.js";
+import { default as N } from "./src/components/Modal/index.js";
+import { default as G } from "./src/components/Nav/index.js";
+import { default as K } from "./src/components/Pagination/index.js";
+import { default as U } from "./src/components/Popconfirm/index.js";
+import { default as X } from "./src/components/Popover/index.js";
+import { default as Z } from "./src/components/Switch/index.js";
+import { default as $ } from "./src/components/Table/index.js";
+import { default as eo } from "./src/components/Timer/index.js";
+import { default as ao } from "./src/components/Tooltip/index.js";
+import { default as fo } from "./src/components/Warn/index.js";
+import { default as mo } from "./src/components/Watermark/index.js";
+import { default as po } from "./src/directives/vDelayIn.js";
+import { default as xo } from "./src/directives/vLazy.js";
+import { default as no } from "./src/directives/vLoading.js";
+import { default as vo } from "./src/directives/vRipple.js";
+import { default as bo } from "./src/directives/vSlideIn.js";
+import { default as Io } from "./src/directives/vTextJump.js";
+import { default as Po } from "./src/directives/vTooltip.js";
+const r = (e) => {
+  Object.values(t).forEach((o) => {
+    e.component(o.name, o);
+  }), Object.values(a).forEach((o) => {
+    e.directive(o.name, o);
+  });
+}, l = {
+  install: r
+};
+export {
+  O as Button,
+  C as Checkbox,
+  E as Dialog,
+  w as Icon,
+  A as Loading,
+  F as Message,
+  N as Modal,
+  G as Nav,
+  K as Pagination,
+  U as Popconfirm,
+  X as Popover,
+  Z as Switch,
+  $ as Table,
+  eo as Timer,
+  ao as Tooltip,
+  fo as Warn,
+  mo as Watermark,
+  c as chance,
+  v as debounce,
+  g as deepClone,
+  l as default,
+  p as dialog,
+  b as getId,
+  h as getRandomInt,
+  I as getRandomStr,
+  r as install,
+  T as isMobile,
+  P as isObject,
+  S as isPromise,
+  u as localStorage,
+  i as msg,
+  j as omit,
+  k as pick,
+  y as shuffleArray,
+  L as throttleFirst,
+  po as vDelayIn,
+  xo as vLazy,
+  no as vLoading,
+  vo as vRipple,
+  bo as vSlideIn,
+  Io as vTextJump,
+  Po as vTooltip
+};

package/dist/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -0,0 +1,393 @@
+import { evaluate as Y, getSide as B, getSideAxis as V, getOppositePlacement as J, getExpandedPlacements as K, getOppositeAxisPlacements as N, getAlignmentSides as Q, clamp as $, getAlignment as X, getOppositeAxis as U, getPaddingObject as W, getAlignmentAxis as _, getAxisLength as q, min as z, rectToClientRect as H } from "../../utils/dist/floating-ui.utils.js";
+function I(a, i, m) {
+  let {
+    reference: n,
+    floating: r
+  } = a;
+  const t = V(i), o = _(i), s = q(o), d = B(i), g = t === "y", x = n.x + n.width / 2 - r.width / 2, l = n.y + n.height / 2 - r.height / 2, f = n[s] / 2 - r[s] / 2;
+  let e;
+  switch (d) {
+    case "top":
+      e = {
+        x,
+        y: n.y - r.height
+      };
+      break;
+    case "bottom":
+      e = {
+        x,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      e = {
+        x: n.x + n.width,
+        y: l
+      };
+      break;
+    case "left":
+      e = {
+        x: n.x - r.width,
+        y: l
+      };
+      break;
+    default:
+      e = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (X(i)) {
+    case "start":
+      e[o] -= f * (m && g ? -1 : 1);
+      break;
+    case "end":
+      e[o] += f * (m && g ? -1 : 1);
+      break;
+  }
+  return e;
+}
+async function Z(a, i) {
+  var m;
+  i === void 0 && (i = {});
+  const {
+    x: n,
+    y: r,
+    platform: t,
+    rects: o,
+    elements: s,
+    strategy: d
+  } = a, {
+    boundary: g = "clippingAncestors",
+    rootBoundary: x = "viewport",
+    elementContext: l = "floating",
+    altBoundary: f = !1,
+    padding: e = 0
+  } = Y(i, a), c = W(e), u = s[f ? l === "floating" ? "reference" : "floating" : l], p = H(await t.getClippingRect({
+    element: (m = await (t.isElement == null ? void 0 : t.isElement(u))) == null || m ? u : u.contextElement || await (t.getDocumentElement == null ? void 0 : t.getDocumentElement(s.floating)),
+    boundary: g,
+    rootBoundary: x,
+    strategy: d
+  })), y = l === "floating" ? {
+    x: n,
+    y: r,
+    width: o.floating.width,
+    height: o.floating.height
+  } : o.reference, v = await (t.getOffsetParent == null ? void 0 : t.getOffsetParent(s.floating)), h = await (t.isElement == null ? void 0 : t.isElement(v)) ? await (t.getScale == null ? void 0 : t.getScale(v)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, P = H(t.convertOffsetParentRelativeRectToViewportRelativeRect ? await t.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: s,
+    rect: y,
+    offsetParent: v,
+    strategy: d
+  }) : y);
+  return {
+    top: (p.top - P.top + c.top) / h.y,
+    bottom: (P.bottom - p.bottom + c.bottom) / h.y,
+    left: (p.left - P.left + c.left) / h.x,
+    right: (P.right - p.right + c.right) / h.x
+  };
+}
+const ie = async (a, i, m) => {
+  const {
+    placement: n = "bottom",
+    strategy: r = "absolute",
+    middleware: t = [],
+    platform: o
+  } = m, s = t.filter(Boolean), d = await (o.isRTL == null ? void 0 : o.isRTL(i));
+  let g = await o.getElementRects({
+    reference: a,
+    floating: i,
+    strategy: r
+  }), {
+    x,
+    y: l
+  } = I(g, n, d), f = n, e = {}, c = 0;
+  for (let u = 0; u < s.length; u++) {
+    var w;
+    const {
+      name: p,
+      fn: y
+    } = s[u], {
+      x: v,
+      y: h,
+      data: P,
+      reset: b
+    } = await y({
+      x,
+      y: l,
+      initialPlacement: n,
+      placement: f,
+      strategy: r,
+      middlewareData: e,
+      rects: g,
+      platform: {
+        ...o,
+        detectOverflow: (w = o.detectOverflow) != null ? w : Z
+      },
+      elements: {
+        reference: a,
+        floating: i
+      }
+    });
+    x = v ?? x, l = h ?? l, e = {
+      ...e,
+      [p]: {
+        ...e[p],
+        ...P
+      }
+    }, b && c <= 50 && (c++, typeof b == "object" && (b.placement && (f = b.placement), b.rects && (g = b.rects === !0 ? await o.getElementRects({
+      reference: a,
+      floating: i,
+      strategy: r
+    }) : b.rects), {
+      x,
+      y: l
+    } = I(g, f, d)), u = -1);
+  }
+  return {
+    x,
+    y: l,
+    placement: f,
+    strategy: r,
+    middlewareData: e
+  };
+}, oe = (a) => ({
+  name: "arrow",
+  options: a,
+  async fn(i) {
+    const {
+      x: m,
+      y: n,
+      placement: r,
+      rects: t,
+      platform: o,
+      elements: s,
+      middlewareData: d
+    } = i, {
+      element: g,
+      padding: x = 0
+    } = Y(a, i) || {};
+    if (g == null)
+      return {};
+    const l = W(x), f = {
+      x: m,
+      y: n
+    }, e = _(r), c = q(e), w = await o.getDimensions(g), u = e === "y", p = u ? "top" : "left", y = u ? "bottom" : "right", v = u ? "clientHeight" : "clientWidth", h = t.reference[c] + t.reference[e] - f[e] - t.floating[c], P = f[e] - t.reference[e], b = await (o.getOffsetParent == null ? void 0 : o.getOffsetParent(g));
+    let D = b ? b[v] : 0;
+    (!D || !await (o.isElement == null ? void 0 : o.isElement(b))) && (D = s.floating[v] || t.floating[c]);
+    const F = h / 2 - P / 2, E = D / 2 - w[c] / 2 - 1, k = z(l[p], E), M = z(l[y], E), T = k, j = D - w[c] - M, A = D / 2 - w[c] / 2 + F, L = $(T, A, j), C = !d.arrow && X(r) != null && A !== L && t.reference[c] / 2 - (A < T ? k : M) - w[c] / 2 < 0, O = C ? A < T ? A - T : A - j : 0;
+    return {
+      [e]: f[e] + O,
+      data: {
+        [e]: L,
+        centerOffset: A - L - O,
+        ...C && {
+          alignmentOffset: O
+        }
+      },
+      reset: C
+    };
+  }
+}), se = function(a) {
+  return a === void 0 && (a = {}), {
+    name: "flip",
+    options: a,
+    async fn(i) {
+      var m, n;
+      const {
+        placement: r,
+        middlewareData: t,
+        rects: o,
+        initialPlacement: s,
+        platform: d,
+        elements: g
+      } = i, {
+        mainAxis: x = !0,
+        crossAxis: l = !0,
+        fallbackPlacements: f,
+        fallbackStrategy: e = "bestFit",
+        fallbackAxisSideDirection: c = "none",
+        flipAlignment: w = !0,
+        ...u
+      } = Y(a, i);
+      if ((m = t.arrow) != null && m.alignmentOffset)
+        return {};
+      const p = B(r), y = V(s), v = B(s) === s, h = await (d.isRTL == null ? void 0 : d.isRTL(g.floating)), P = f || (v || !w ? [J(s)] : K(s)), b = c !== "none";
+      !f && b && P.push(...N(s, w, c, h));
+      const D = [s, ...P], F = await d.detectOverflow(i, u), E = [];
+      let k = ((n = t.flip) == null ? void 0 : n.overflows) || [];
+      if (x && E.push(F[p]), l) {
+        const A = Q(r, o, h);
+        E.push(F[A[0]], F[A[1]]);
+      }
+      if (k = [...k, {
+        placement: r,
+        overflows: E
+      }], !E.every((A) => A <= 0)) {
+        var M, T;
+        const A = (((M = t.flip) == null ? void 0 : M.index) || 0) + 1, L = D[A];
+        if (L && (!(l === "alignment" ? y !== V(L) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        k.every((R) => V(R.placement) === y ? R.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: A,
+              overflows: k
+            },
+            reset: {
+              placement: L
+            }
+          };
+        let C = (T = k.filter((O) => O.overflows[0] <= 0).sort((O, R) => O.overflows[1] - R.overflows[1])[0]) == null ? void 0 : T.placement;
+        if (!C)
+          switch (e) {
+            case "bestFit": {
+              var j;
+              const O = (j = k.filter((R) => {
+                if (b) {
+                  const S = V(R.placement);
+                  return S === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  S === "y";
+                }
+                return !0;
+              }).map((R) => [R.placement, R.overflows.filter((S) => S > 0).reduce((S, G) => S + G, 0)]).sort((R, S) => R[1] - S[1])[0]) == null ? void 0 : j[0];
+              O && (C = O);
+              break;
+            }
+            case "initialPlacement":
+              C = s;
+              break;
+          }
+        if (r !== C)
+          return {
+            reset: {
+              placement: C
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, ee = /* @__PURE__ */ new Set(["left", "top"]);
+async function te(a, i) {
+  const {
+    placement: m,
+    platform: n,
+    elements: r
+  } = a, t = await (n.isRTL == null ? void 0 : n.isRTL(r.floating)), o = B(m), s = X(m), d = V(m) === "y", g = ee.has(o) ? -1 : 1, x = t && d ? -1 : 1, l = Y(i, a);
+  let {
+    mainAxis: f,
+    crossAxis: e,
+    alignmentAxis: c
+  } = typeof l == "number" ? {
+    mainAxis: l,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: l.mainAxis || 0,
+    crossAxis: l.crossAxis || 0,
+    alignmentAxis: l.alignmentAxis
+  };
+  return s && typeof c == "number" && (e = s === "end" ? c * -1 : c), d ? {
+    x: e * x,
+    y: f * g
+  } : {
+    x: f * g,
+    y: e * x
+  };
+}
+const ae = function(a) {
+  return a === void 0 && (a = 0), {
+    name: "offset",
+    options: a,
+    async fn(i) {
+      var m, n;
+      const {
+        x: r,
+        y: t,
+        placement: o,
+        middlewareData: s
+      } = i, d = await te(i, a);
+      return o === ((m = s.offset) == null ? void 0 : m.placement) && (n = s.arrow) != null && n.alignmentOffset ? {} : {
+        x: r + d.x,
+        y: t + d.y,
+        data: {
+          ...d,
+          placement: o
+        }
+      };
+    }
+  };
+}, le = function(a) {
+  return a === void 0 && (a = {}), {
+    name: "shift",
+    options: a,
+    async fn(i) {
+      const {
+        x: m,
+        y: n,
+        placement: r,
+        platform: t
+      } = i, {
+        mainAxis: o = !0,
+        crossAxis: s = !1,
+        limiter: d = {
+          fn: (p) => {
+            let {
+              x: y,
+              y: v
+            } = p;
+            return {
+              x: y,
+              y: v
+            };
+          }
+        },
+        ...g
+      } = Y(a, i), x = {
+        x: m,
+        y: n
+      }, l = await t.detectOverflow(i, g), f = V(B(r)), e = U(f);
+      let c = x[e], w = x[f];
+      if (o) {
+        const p = e === "y" ? "top" : "left", y = e === "y" ? "bottom" : "right", v = c + l[p], h = c - l[y];
+        c = $(v, c, h);
+      }
+      if (s) {
+        const p = f === "y" ? "top" : "left", y = f === "y" ? "bottom" : "right", v = w + l[p], h = w - l[y];
+        w = $(v, w, h);
+      }
+      const u = d.fn({
+        ...i,
+        [e]: c,
+        [f]: w
+      });
+      return {
+        ...u,
+        data: {
+          x: u.x - m,
+          y: u.y - n,
+          enabled: {
+            [e]: o,
+            [f]: s
+          }
+        }
+      };
+    }
+  };
+};
+export {
+  oe as arrow,
+  ie as computePosition,
+  Z as detectOverflow,
+  se as flip,
+  ae as offset,
+  H as rectToClientRect,
+  le as shift
+};