tttb 0.0.20

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 TB
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# tb-ui
+
+This template should help get you started developing with Vue 3 in Vite.
+
+## Recommended IDE Setup
+
+[VS Code](https://code.visualstudio.com/) + [Vue (Official)](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur).
+
+## Recommended Browser Setup
+
+- Chromium-based browsers (Chrome, Edge, Brave, etc.):
+  - [Vue.js devtools](https://chromewebstore.google.com/detail/vuejs-devtools/nhdogjmejiglipccpnnnanhbledajbpd) 
+  - [Turn on Custom Object Formatter in Chrome DevTools](http://bit.ly/object-formatters)
+- Firefox:
+  - [Vue.js devtools](https://addons.mozilla.org/en-US/firefox/addon/vue-js-devtools/)
+  - [Turn on Custom Object Formatter in Firefox DevTools](https://fxdx.dev/firefox-devtools-custom-object-formatters/)
+
+## Customize configuration
+
+See [Vite Configuration Reference](https://vite.dev/config/).
+
+## Project Setup
+
+```sh
+npm install
+```
+
+### Compile and Hot-Reload for Development
+
+```sh
+npm run dev
+```
+
+### Compile and Minify for Production
+
+```sh
+npm run build
+```

package/dist/es/_virtual/_plugin-vue_export-helper.js

@@ -0,0 +1,9 @@
+const s = (t, e) => {
+  const o = t.__vccOpts || t;
+  for (const [r, c] of e)
+    o[r] = c;
+  return o;
+};
+export {
+  s as default
+};

package/dist/es/components.js

@@ -0,0 +1,32 @@
+import { default as e } from "./src/components/Button/index.js";
+import { default as r } from "./src/components/Checkbox/index.js";
+import { default as l } from "./src/components/Dialog/index.js";
+import { default as m } from "./src/components/Icon/index.js";
+import { default as p } from "./src/components/Loading/index.js";
+import { default as x } from "./src/components/Message/index.js";
+import { default as n } from "./src/components/Modal/index.js";
+import { default as c } from "./src/components/Nav/index.js";
+import { default as b } from "./src/components/Pagination/index.js";
+import { default as k } from "./src/components/Switch/index.js";
+import { default as W } from "./src/components/Table/index.js";
+import { default as w } from "./src/components/Timer/index.js";
+import { default as C } from "./src/components/Tooltip/index.js";
+import { default as I } from "./src/components/Warn/index.js";
+import { default as N } from "./src/components/Watermark/index.js";
+export {
+  e as Button,
+  r as Checkbox,
+  l as Dialog,
+  m as Icon,
+  p as Loading,
+  x as Message,
+  n as Modal,
+  c as Nav,
+  b as Pagination,
+  k as Switch,
+  W as Table,
+  w as Timer,
+  C as Tooltip,
+  I as Warn,
+  N as Watermark
+};

package/dist/es/directives.js

@@ -0,0 +1,14 @@
+import { default as o } from "./src/directives/vDelayIn.js";
+import { default as f } from "./src/directives/vLazy.js";
+import { default as l } from "./src/directives/vLoading.js";
+import { default as p } from "./src/directives/vSlideIn.js";
+import { default as u } from "./src/directives/vTextJump.js";
+import { default as s } from "./src/directives/vTooltip.js";
+export {
+  o as vDelayIn,
+  f as vLazy,
+  l as vLoading,
+  p as vSlideIn,
+  u as vTextJump,
+  s as vTooltip
+};

package/dist/es/hooks.js

@@ -0,0 +1,4 @@
+import { useScrollControl as l } from "./src/hooks/useScrollControl.js";
+export {
+  l as useScrollControl
+};

package/dist/es/index.js

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

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

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