@opentiny/tiny-robot 0.1.0 → 0.2.0-alpha.1

package/dist/node_modules/.pnpm/@opentiny_vue-renderless@3.22.0/node_modules/@opentiny/vue-renderless/tooltip/index.js

@@ -0,0 +1,77 @@
+import { debounce as d, on as r, addClass as f, removeClass as a, off as c } from "../../../../../@opentiny_utils@3.22.0/node_modules/@opentiny/utils/dist/index.es.js";
+const m = ({ api: e, state: o, props: t }) => (n) => {
+  const s = n && n.type === "mouseenter" ? 200 : 0;
+  if (t.visible === "auto") {
+    const { clientWidth: u, scrollWidth: i } = o.referenceElm;
+    if (i <= u)
+      return;
+  }
+  e.setExpectedState(!0), e.handleShowPopper(s);
+}, h = (e) => () => {
+  e.setExpectedState(!1), e.debounceClose();
+}, b = ({ api: e, state: o }) => () => {
+  o.focusing = !0, e.show();
+}, g = ({ api: e, state: o }) => () => {
+  o.focusing = !1, e.hide();
+}, w = ({ api: e, state: o }) => () => {
+  o.focusing = !1, e.show();
+}, y = ({ props: e, state: o }) => (t) => {
+  !o.expectedState || e.manual || (clearTimeout(o.timeout), o.timeout = window.setTimeout(() => {
+    o.showPopper = !0;
+  }, e.openDelay || t), e.hideAfter > 0 && (o.timeoutPending = window.setTimeout(() => {
+    o.showPopper = !1;
+  }, e.hideAfter)));
+}, P = ({ api: e, props: o, state: t }) => () => {
+  o.enterable && t.expectedState || o.manual || (clearTimeout(t.timeout), t.timeoutPending && clearTimeout(t.timeoutPending), t.showPopper = !1, o.disabled && e.doDestroy());
+}, E = ({ props: e, api: o, state: t, popperVmRef: n }) => (l) => {
+  if (e.manual)
+    return;
+  const s = t.referenceElm, u = n.popper;
+  !u || !s || u.contains(l.target) || s.contains(l.target) || t.showPopper && (o.setExpectedState(!1), o.debounceClose());
+}, x = ({ state: e }) => (o) => {
+  e.expectedState === !1 && clearTimeout(e.timeoutPending), e.expectedState = o;
+}, C = ({ state: e, api: o, vm: t }) => () => {
+  const n = e.referenceElm;
+  e.showPopper = !1, n && n.nodeType === 1 && (c(document, "click", o.handleDocumentClick), c(n, "mouseenter", o.show), c(n, "mouseleave", o.hide), c(n, "focus", o.focusHandler), c(n, "blur", o.handleBlur), c(n, "click", o.removeFocusing)), t.popperVM && (typeof t.popperVM.$destroy == "function" && t.popperVM.$destroy(), t.popperVM = null);
+}, S = ({ api: e, props: o }) => d(o.closeDelay, () => {
+  e.handleClosePopper();
+}), T = (e) => (o) => {
+  o ? f(e.referenceElm, "focusing") : a(e.referenceElm, "focusing");
+}, $ = ({ slots: e, api: o }) => () => {
+  if (!e.default || !e.default().length) {
+    o.handleFocus();
+    return;
+  }
+  let t = e.default()[0];
+  t = t.elm || t.el, t && t.focus ? t.focus() : o.handleFocus();
+}, D = ({ api: e, state: o, vm: t }) => (n) => {
+  let l = null;
+  t.$el.nodeType === 8 ? l = n : t.$el.nodeType === 1 && (l = t.$el), !(!l || l.nodeType === 8 || o.referenceElm) && (o.referenceElm = l, l.setAttribute("aria-describedby", o.tooltipId), l.setAttribute("tabindex", o.tabindex.toString()), r(document, "click", e.handleDocumentClick), r(l, "mouseenter", e.show), r(l, "mouseleave", e.hide), r(l, "focus", e.focusHandler), r(l, "blur", e.handleBlur), r(l, "click", e.removeFocusing));
+}, k = ({ state: e, popperVmRef: o }) => (t) => {
+  for (let n of t)
+    n.type === "attributes" && n.attributeName === "x-placement" && (e.xPlacement = o.popper.getAttribute("x-placement") || "bottom");
+}, F = ({ vm: e, nextTick: o, popperVmRef: t }) => (n) => {
+  o(() => e.bindEvent(n));
+  let l = e.popperVM;
+  e.$refs.popper ? t.popper = e.$refs.popper : t.popper = l.$el, o(() => {
+    e.modelValue && e.updatePopper();
+  });
+};
+export {
+  D as bindEvent,
+  F as bindPopper,
+  S as debounceClose,
+  C as destroyed,
+  $ as focusHandler,
+  g as handleBlur,
+  P as handleClosePopper,
+  E as handleDocumentClick,
+  b as handleFocus,
+  y as handleShowPopper,
+  h as hide,
+  k as observeCallback,
+  w as removeFocusing,
+  x as setExpectedState,
+  m as show,
+  T as watchFocusing
+};

package/dist/node_modules/.pnpm/@opentiny_vue-renderless@3.22.0/node_modules/@opentiny/vue-renderless/tooltip/vue.js

@@ -0,0 +1,90 @@
+import { observeCallback as y, handleDocumentClick as k, focusHandler as D, bindEvent as H, handleClosePopper as B, handleShowPopper as O, setExpectedState as $, debounceClose as M, handleFocus as V, handleBlur as j, removeFocusing as A, watchFocusing as I, bindPopper as J, destroyed as L, hide as R, show as W } from "./index.js";
+import { guid as q } from "../../../../../@opentiny_utils@3.22.0/node_modules/@opentiny/utils/dist/index.es.js";
+import { userPopper as z } from "../../../../../@opentiny_vue-hooks@3.22.0/node_modules/@opentiny/vue-hooks/dist/src/vue-popper.js";
+const U = [
+  "state",
+  "bindEvent",
+  "hide",
+  "show",
+  "doDestroy",
+  "handleFocus",
+  "debounceClose",
+  "handleShowPopper",
+  "handleClosePopper",
+  "setExpectedState",
+  "updatePopper",
+  "focusHandler"
+], G = ({ reactive: t, showPopper: a, popperElm: d, referenceElm: r, props: i, inject: p, popperJS: l, currentPlacement: c }) => t({
+  popperJS: l,
+  showPopper: a,
+  popperElm: d,
+  referenceElm: r,
+  currentPlacement: c,
+  timeout: null,
+  focusing: !1,
+  expectedState: void 0,
+  tooltipId: q("tiny-tooltip-", 4),
+  tabindex: i.tabindex,
+  xPlacement: "bottom",
+  showContent: p("showContent", null),
+  tipsMaxWidth: p("tips-max-width", null)
+}), X = (t, {
+  watch: a,
+  toRefs: d,
+  reactive: r,
+  onBeforeUnmount: i,
+  onDeactivated: p,
+  onMounted: l,
+  onUnmounted: c,
+  inject: f
+}, { vm: n, emit: m, slots: b, nextTick: u, parent: w }) => {
+  const e = {}, s = {}, P = { emit: m, props: t, nextTick: u, toRefs: d, reactive: r, parent: w.$parent, vm: n, popperVmRef: s };
+  Object.assign(P, { slots: b, onBeforeUnmount: i, onDeactivated: p, watch: a });
+  const { showPopper: C, updatePopper: g, popperElm: v, referenceElm: S, doDestroy: x, popperJS: E, currentPlacement: F } = z(
+    P
+  ), o = G({
+    reactive: r,
+    showPopper: C,
+    popperElm: v,
+    referenceElm: S,
+    props: t,
+    inject: f,
+    popperJS: E,
+    currentPlacement: F
+  });
+  return Object.assign(e, {
+    state: o,
+    doDestroy: x,
+    updatePopper: g,
+    show: W({ api: e, state: o, props: t }),
+    hide: R(e),
+    destroyed: L({ state: o, api: e, vm: n }),
+    bindPopper: J({ vm: n, nextTick: u, popperVmRef: s }),
+    watchFocusing: I(o),
+    removeFocusing: A({ api: e, state: o }),
+    handleBlur: j({ api: e, state: o }),
+    handleFocus: V({ api: e, state: o }),
+    debounceClose: M({ api: e, props: t }),
+    setExpectedState: $({ state: o }),
+    handleShowPopper: O({ props: t, state: o }),
+    handleClosePopper: B({ api: e, props: t, state: o }),
+    bindEvent: H({ api: e, state: o, vm: n }),
+    focusHandler: D({ slots: b, api: e }),
+    handleDocumentClick: k({ props: t, api: e, state: o, popperVmRef: s }),
+    observeCallback: y({ state: o, popperVmRef: s })
+  }), a(() => o.focusing, e.watchFocusing), a(
+    () => t.modelValue,
+    (h) => u(() => t.manual && (o.showPopper = h))
+  ), l(() => {
+    if (e.bindPopper(), t.genArrowByHtml) {
+      const h = { attributes: !0, childList: !1, subtree: !1 };
+      e.observer = new MutationObserver(e.observeCallback), e.observer.observe(s.popper, h);
+    }
+  }), n.$on("tooltip-update", e.bindPopper), c(() => {
+    e.destroyed(), e.observer && e.observer.disconnect(), n.$off("tooltip-update");
+  }), e;
+};
+export {
+  U as api,
+  X as renderless
+};

package/dist/node_modules/.pnpm/@opentiny_vue-tooltip@3.22.0/node_modules/@opentiny/vue-tooltip/lib/index.js

@@ -0,0 +1,176 @@
+import { defineComponent as l, $setup as f, $prefix as i, $props as p } from "../../../../../@opentiny_vue-common@3.22.0/node_modules/@opentiny/vue-common/lib/index.js";
+import o from "./pc.js";
+function a() {
+  return a = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var n = arguments[t];
+      for (var r in n) ({}).hasOwnProperty.call(n, r) && (e[r] = n[r]);
+    }
+    return e;
+  }, a.apply(null, arguments);
+}
+var d = function(t) {
+  var n, r = typeof process == "object" ? (n = process.env) == null ? void 0 : n.TINY_MODE : null;
+  return (r || t) === "pc" ? o : (r || t) === "mobile-first" ? o : o;
+}, c = a({}, p, {
+  visible: {
+    type: String,
+    default: function() {
+      return "always";
+    },
+    validator: function(t) {
+      return ["always", "auto"].includes(t);
+    }
+  },
+  adjustArrow: {
+    type: Boolean,
+    default: function() {
+      return !1;
+    }
+  },
+  appendToBody: {
+    type: Boolean,
+    default: function() {
+      return !0;
+    }
+  },
+  arrowOffset: {
+    type: Number,
+    default: function() {
+      return 0;
+    }
+  },
+  content: {
+    type: [String, Object]
+  },
+  disabled: {
+    type: Boolean
+  },
+  enterable: {
+    type: Boolean,
+    default: function() {
+      return !0;
+    }
+  },
+  hideAfter: {
+    type: Number,
+    default: function() {
+      return 0;
+    }
+  },
+  manual: {
+    type: Boolean
+  },
+  modelValue: {
+    type: Boolean
+  },
+  offset: {
+    default: function() {
+      return 0;
+    }
+  },
+  effect: {
+    type: String,
+    default: function() {
+      return "";
+    }
+  },
+  openDelay: {
+    type: Number,
+    default: function() {
+      return 0;
+    }
+  },
+  closeDelay: {
+    type: Number,
+    default: function() {
+      return 100;
+    }
+  },
+  placement: {
+    type: String,
+    default: function() {
+      return "bottom";
+    }
+  },
+  popper: {},
+  popperClass: {
+    type: String
+  },
+  popperOptions: {
+    default: function() {
+      return {};
+    }
+  },
+  pre: {
+    type: Boolean
+  },
+  reference: {},
+  renderContent: {
+    type: Function
+  },
+  tabindex: {
+    type: Number,
+    default: function() {
+      return 0;
+    }
+  },
+  transition: {
+    type: String,
+    default: function() {
+      return "tiny-fade-in-linear";
+    }
+  },
+  type: {
+    type: String,
+    validator: function(t) {
+      return !!~["normal", "warning", "error", "info", "success"].indexOf(t);
+    }
+  },
+  visibleArrow: {
+    type: Boolean,
+    default: function() {
+      return !0;
+    }
+  },
+  genArrowByHtml: {
+    type: Boolean,
+    default: function() {
+      return !0;
+    }
+  },
+  zIndex: {
+    type: String,
+    default: function() {
+      return "next";
+    }
+  },
+  contentMaxHeight: {
+    type: String,
+    default: function() {
+      return "80vh";
+    }
+  }
+}), u = l({
+  name: i + "Tooltip",
+  componentName: "Tooltip",
+  props: c,
+  setup: function(t, n) {
+    return f({
+      props: t,
+      context: n,
+      template: d
+    });
+  }
+}), s = "3.undefined";
+u.model = {
+  prop: "modelValue",
+  event: "update:modelValue"
+};
+u.install = function(e) {
+  e.component(u.name, u);
+};
+u.version = s;
+export {
+  u as default
+};

package/dist/node_modules/.pnpm/@opentiny_vue-tooltip@3.22.0/node_modules/@opentiny/vue-tooltip/lib/pc.js

@@ -0,0 +1,248 @@
+import * as y from "vue";
+import { withDirectives as h, createVNode as m, vShow as C } from "vue";
+import { renderless as w, api as x } from "../../../../../@opentiny_vue-renderless@3.22.0/node_modules/@opentiny/vue-renderless/tooltip/vue.js";
+import { defineComponent as S, createComponent as B, h as f, deduplicateCssClass as M, stringifyCssClass as O, setup as N, $prefix as P, parseVnode as E, isEmptyVnode as A, $props as D } from "../../../../../@opentiny_vue-common@3.22.0/node_modules/@opentiny/vue-common/lib/index.js";
+/* empty css                                                                                           */
+function d() {
+  return d = Object.assign ? Object.assign.bind() : function(t) {
+    for (var e = 1; e < arguments.length; e++) {
+      var u = arguments[e];
+      for (var a in u) ({}).hasOwnProperty.call(u, a) && (t[a] = u[a]);
+    }
+    return t;
+  }, d.apply(null, arguments);
+}
+var F = /* @__PURE__ */ S({
+  name: P + "Tooltip",
+  componentName: "Tooltip",
+  props: d({}, D, {
+    visible: {
+      type: String,
+      default: function() {
+        return "always";
+      },
+      validator: function(e) {
+        return ["always", "auto"].includes(e);
+      }
+    },
+    adjustArrow: {
+      type: Boolean,
+      default: function() {
+        return !1;
+      }
+    },
+    appendToBody: {
+      type: Boolean,
+      default: function() {
+        return !0;
+      }
+    },
+    arrowOffset: {
+      type: Number,
+      default: function() {
+        return 0;
+      }
+    },
+    boundariesPadding: {
+      type: Number,
+      default: function() {
+        return 5;
+      }
+    },
+    closeDelay: {
+      type: Number,
+      default: function() {
+        return 300;
+      }
+    },
+    content: {
+      type: [String, Object]
+    },
+    disabled: {
+      type: Boolean
+    },
+    effect: {
+      type: String,
+      default: function() {
+        return "dark";
+      }
+    },
+    enterable: {
+      type: Boolean,
+      default: function() {
+        return !0;
+      }
+    },
+    hideAfter: {
+      type: Number,
+      default: function() {
+        return 0;
+      }
+    },
+    manual: {
+      type: Boolean
+    },
+    modelValue: {
+      type: Boolean
+    },
+    offset: {
+      default: function() {
+        return 0;
+      }
+    },
+    openDelay: {
+      type: Number,
+      default: function() {
+        return 0;
+      }
+    },
+    placement: {
+      type: String,
+      default: function() {
+        return "bottom";
+      }
+    },
+    popper: {},
+    popperClass: {
+      type: String
+    },
+    popperOptions: {
+      default: function() {
+        return {
+          gpuAcceleration: !1,
+          boundariesPadding: 10
+        };
+      }
+    },
+    pre: {
+      type: Boolean
+    },
+    reference: {},
+    renderContent: {
+      type: Function
+    },
+    tabindex: {
+      type: Number,
+      default: function() {
+        return 0;
+      }
+    },
+    transition: {
+      type: String,
+      default: function() {
+        return "tiny-fade-in-linear";
+      }
+    },
+    type: {
+      type: String,
+      validator: function(e) {
+        return !!~["normal", "warning", "error", "info", "success"].indexOf(e);
+      }
+    },
+    visibleArrow: {
+      type: Boolean,
+      default: function() {
+        return !0;
+      }
+    },
+    zIndex: {
+      type: String,
+      default: function() {
+        return "next";
+      }
+    },
+    contentMaxHeight: {
+      type: String
+    }
+  }),
+  setup: function(e, u) {
+    return N({
+      props: e,
+      context: u,
+      renderless: w,
+      api: x
+    });
+  },
+  render: function() {
+    var e = this, u = function(n) {
+      var r = n.slots.content && n.slots.content();
+      if (r && (!y.Comment || r[0].type !== y.Comment))
+        return r;
+      var o;
+      return n.renderContent ? o = n.renderContent(f, n.content) : n.pre ? o = n.content ? f("pre", n.content) : null : o = n.content, o;
+    };
+    if (!Object.prototype.hasOwnProperty.call(this, "popperVM")) {
+      var a = {
+        value: null
+      };
+      this.d({
+        popperVM: {
+          get: function() {
+            return a.value || (a.value = B({
+              el: document.createElement("div"),
+              propsData: null,
+              component: {
+                render: function() {
+                  var r = u(e), o = typeof r == "string", i = {
+                    attrs: {
+                      name: e.transition
+                    },
+                    on: {
+                      "after-leave": e.doDestroy
+                    }
+                  }, g = "is-" + (e.type || e.effect || "dark"), b = function() {
+                    return e.setExpectedState(!0);
+                  }, _ = function() {
+                    e.setExpectedState(!1), e.debounceClose();
+                  };
+                  return e.$nextTick(function() {
+                    !e.disabled && e.state.showPopper && r && e.updatePopper();
+                  }), f("transition", i, [h(m("div", {
+                    ref: "popper",
+                    id: e.state.tooltipId,
+                    class: ["tiny-tooltip", "tiny-tooltip__popper", g, e.popperClass, {
+                      "tiny-tooltip__show-tips": e.state.showContent
+                    }],
+                    style: "max-width:" + e.state.tipsMaxWidth + "px",
+                    role: "tooltip",
+                    "aria-hidden": e.disabled || !e.state.showPopper ? "true" : "false",
+                    onMouseenter: function() {
+                      return b();
+                    },
+                    onMouseleave: function() {
+                      return _();
+                    }
+                  }, [o ? m("div", {
+                    class: "tiny-tooltip__content-wrapper",
+                    style: "max-height:" + e.contentMaxHeight
+                  }, [r]) : r]), [[C, !e.disabled && e.state.showPopper && r]])]);
+                }
+              }
+            })), a.value;
+          },
+          set: function(n) {
+            return a.value = n;
+          }
+        }
+      });
+    }
+    var v = function() {
+      var n = e.slots.default && e.slots.default();
+      if (!Array.isArray(n)) return null;
+      for (var r = null, o = 0; o < n.length; o++) {
+        var i = E(n[o]);
+        if (!A(i)) {
+          r = i;
+          break;
+        }
+      }
+      return r;
+    }, l = v();
+    if (!l) return null;
+    var c = l.data || l.props || (l.props = {});
+    return c.class = M("tiny-tooltip " + O(c.class)), l;
+  }
+});
+export {
+  F as default
+};