@helpdice/ui 2.1.5 → 2.1.9

package/dist/notetip/index.js

@@ -0,0 +1,690 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var reactDom = require('@floating-ui/react-dom');
+var theme = require('@helpdice/theme');
+var reactDom$1 = require('react-dom');
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = true,
+      o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = true, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var index = {};
+
+var hasRequiredIndex;
+
+function requireIndex () {
+	if (hasRequiredIndex) return index;
+	hasRequiredIndex = 1;
+	var React$1 = React;
+
+	function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+	var React__default = /*#__PURE__*/_interopDefaultLegacy(React$1);
+
+	/*
+	Based on Glamor's sheet
+	https://github.com/threepointone/glamor/blob/667b480d31b3721a905021b26e1290ce92ca2879/src/sheet.js
+	*/ function _defineProperties(target, props) {
+	    for(var i = 0; i < props.length; i++){
+	        var descriptor = props[i];
+	        descriptor.enumerable = descriptor.enumerable || false;
+	        descriptor.configurable = true;
+	        if ("value" in descriptor) descriptor.writable = true;
+	        Object.defineProperty(target, descriptor.key, descriptor);
+	    }
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+	    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+	    return Constructor;
+	}
+	var isProd = typeof process !== "undefined" && process.env && process.env.NODE_ENV === "production";
+	var isString = function(o) {
+	    return Object.prototype.toString.call(o) === "[object String]";
+	};
+	var StyleSheet = /*#__PURE__*/ function() {
+	    function StyleSheet(param) {
+	        var ref = param === void 0 ? {} : param, _name = ref.name, name = _name === void 0 ? "stylesheet" : _name, _optimizeForSpeed = ref.optimizeForSpeed, optimizeForSpeed = _optimizeForSpeed === void 0 ? isProd : _optimizeForSpeed;
+	        invariant$1(isString(name), "`name` must be a string");
+	        this._name = name;
+	        this._deletedRulePlaceholder = "#" + name + "-deleted-rule____{}";
+	        invariant$1(typeof optimizeForSpeed === "boolean", "`optimizeForSpeed` must be a boolean");
+	        this._optimizeForSpeed = optimizeForSpeed;
+	        this._serverSheet = undefined;
+	        this._tags = [];
+	        this._injected = false;
+	        this._rulesCount = 0;
+	        var node = typeof window !== "undefined" && document.querySelector('meta[property="csp-nonce"]');
+	        this._nonce = node ? node.getAttribute("content") : null;
+	    }
+	    var _proto = StyleSheet.prototype;
+	    _proto.setOptimizeForSpeed = function setOptimizeForSpeed(bool) {
+	        invariant$1(typeof bool === "boolean", "`setOptimizeForSpeed` accepts a boolean");
+	        invariant$1(this._rulesCount === 0, "optimizeForSpeed cannot be when rules have already been inserted");
+	        this.flush();
+	        this._optimizeForSpeed = bool;
+	        this.inject();
+	    };
+	    _proto.isOptimizeForSpeed = function isOptimizeForSpeed() {
+	        return this._optimizeForSpeed;
+	    };
+	    _proto.inject = function inject() {
+	        var _this = this;
+	        invariant$1(!this._injected, "sheet already injected");
+	        this._injected = true;
+	        if (typeof window !== "undefined" && this._optimizeForSpeed) {
+	            this._tags[0] = this.makeStyleTag(this._name);
+	            this._optimizeForSpeed = "insertRule" in this.getSheet();
+	            if (!this._optimizeForSpeed) {
+	                if (!isProd) {
+	                    console.warn("StyleSheet: optimizeForSpeed mode not supported falling back to standard mode.");
+	                }
+	                this.flush();
+	                this._injected = true;
+	            }
+	            return;
+	        }
+	        this._serverSheet = {
+	            cssRules: [],
+	            insertRule: function(rule, index) {
+	                if (typeof index === "number") {
+	                    _this._serverSheet.cssRules[index] = {
+	                        cssText: rule
+	                    };
+	                } else {
+	                    _this._serverSheet.cssRules.push({
+	                        cssText: rule
+	                    });
+	                }
+	                return index;
+	            },
+	            deleteRule: function(index) {
+	                _this._serverSheet.cssRules[index] = null;
+	            }
+	        };
+	    };
+	    _proto.getSheetForTag = function getSheetForTag(tag) {
+	        if (tag.sheet) {
+	            return tag.sheet;
+	        }
+	        // this weirdness brought to you by firefox
+	        for(var i = 0; i < document.styleSheets.length; i++){
+	            if (document.styleSheets[i].ownerNode === tag) {
+	                return document.styleSheets[i];
+	            }
+	        }
+	    };
+	    _proto.getSheet = function getSheet() {
+	        return this.getSheetForTag(this._tags[this._tags.length - 1]);
+	    };
+	    _proto.insertRule = function insertRule(rule, index) {
+	        invariant$1(isString(rule), "`insertRule` accepts only strings");
+	        if (typeof window === "undefined") {
+	            if (typeof index !== "number") {
+	                index = this._serverSheet.cssRules.length;
+	            }
+	            this._serverSheet.insertRule(rule, index);
+	            return this._rulesCount++;
+	        }
+	        if (this._optimizeForSpeed) {
+	            var sheet = this.getSheet();
+	            if (typeof index !== "number") {
+	                index = sheet.cssRules.length;
+	            }
+	            // this weirdness for perf, and chrome's weird bug
+	            // https://stackoverflow.com/questions/20007992/chrome-suddenly-stopped-accepting-insertrule
+	            try {
+	                sheet.insertRule(rule, index);
+	            } catch (error) {
+	                if (!isProd) {
+	                    console.warn("StyleSheet: illegal rule: \n\n" + rule + "\n\nSee https://stackoverflow.com/q/20007992 for more info");
+	                }
+	                return -1;
+	            }
+	        } else {
+	            var insertionPoint = this._tags[index];
+	            this._tags.push(this.makeStyleTag(this._name, rule, insertionPoint));
+	        }
+	        return this._rulesCount++;
+	    };
+	    _proto.replaceRule = function replaceRule(index, rule) {
+	        if (this._optimizeForSpeed || typeof window === "undefined") {
+	            var sheet = typeof window !== "undefined" ? this.getSheet() : this._serverSheet;
+	            if (!rule.trim()) {
+	                rule = this._deletedRulePlaceholder;
+	            }
+	            if (!sheet.cssRules[index]) {
+	                // @TBD Should we throw an error?
+	                return index;
+	            }
+	            sheet.deleteRule(index);
+	            try {
+	                sheet.insertRule(rule, index);
+	            } catch (error) {
+	                if (!isProd) {
+	                    console.warn("StyleSheet: illegal rule: \n\n" + rule + "\n\nSee https://stackoverflow.com/q/20007992 for more info");
+	                }
+	                // In order to preserve the indices we insert a deleteRulePlaceholder
+	                sheet.insertRule(this._deletedRulePlaceholder, index);
+	            }
+	        } else {
+	            var tag = this._tags[index];
+	            invariant$1(tag, "old rule at index `" + index + "` not found");
+	            tag.textContent = rule;
+	        }
+	        return index;
+	    };
+	    _proto.deleteRule = function deleteRule(index) {
+	        if (typeof window === "undefined") {
+	            this._serverSheet.deleteRule(index);
+	            return;
+	        }
+	        if (this._optimizeForSpeed) {
+	            this.replaceRule(index, "");
+	        } else {
+	            var tag = this._tags[index];
+	            invariant$1(tag, "rule at index `" + index + "` not found");
+	            tag.parentNode.removeChild(tag);
+	            this._tags[index] = null;
+	        }
+	    };
+	    _proto.flush = function flush() {
+	        this._injected = false;
+	        this._rulesCount = 0;
+	        if (typeof window !== "undefined") {
+	            this._tags.forEach(function(tag) {
+	                return tag && tag.parentNode.removeChild(tag);
+	            });
+	            this._tags = [];
+	        } else {
+	            // simpler on server
+	            this._serverSheet.cssRules = [];
+	        }
+	    };
+	    _proto.cssRules = function cssRules() {
+	        var _this = this;
+	        if (typeof window === "undefined") {
+	            return this._serverSheet.cssRules;
+	        }
+	        return this._tags.reduce(function(rules, tag) {
+	            if (tag) {
+	                rules = rules.concat(Array.prototype.map.call(_this.getSheetForTag(tag).cssRules, function(rule) {
+	                    return rule.cssText === _this._deletedRulePlaceholder ? null : rule;
+	                }));
+	            } else {
+	                rules.push(null);
+	            }
+	            return rules;
+	        }, []);
+	    };
+	    _proto.makeStyleTag = function makeStyleTag(name, cssString, relativeToTag) {
+	        if (cssString) {
+	            invariant$1(isString(cssString), "makeStyleTag accepts only strings as second parameter");
+	        }
+	        var tag = document.createElement("style");
+	        if (this._nonce) tag.setAttribute("nonce", this._nonce);
+	        tag.type = "text/css";
+	        tag.setAttribute("data-" + name, "");
+	        if (cssString) {
+	            tag.appendChild(document.createTextNode(cssString));
+	        }
+	        var head = document.head || document.getElementsByTagName("head")[0];
+	        if (relativeToTag) {
+	            head.insertBefore(tag, relativeToTag);
+	        } else {
+	            head.appendChild(tag);
+	        }
+	        return tag;
+	    };
+	    _createClass(StyleSheet, [
+	        {
+	            key: "length",
+	            get: function get() {
+	                return this._rulesCount;
+	            }
+	        }
+	    ]);
+	    return StyleSheet;
+	}();
+	function invariant$1(condition, message) {
+	    if (!condition) {
+	        throw new Error("StyleSheet: " + message + ".");
+	    }
+	}
+
+	function hash(str) {
+	    var _$hash = 5381, i = str.length;
+	    while(i){
+	        _$hash = _$hash * 33 ^ str.charCodeAt(--i);
+	    }
+	    /* JavaScript does bitwise operations (like XOR, above) on 32-bit signed
+	   * integers. Since we want the results to be always positive, convert the
+	   * signed int to an unsigned by doing an unsigned bitshift. */ return _$hash >>> 0;
+	}
+	var stringHash = hash;
+
+	var sanitize = function(rule) {
+	    return rule.replace(/\/style/gi, "\\/style");
+	};
+	var cache = {};
+	/**
+	 * computeId
+	 *
+	 * Compute and memoize a jsx id from a basedId and optionally props.
+	 */ function computeId(baseId, props) {
+	    if (!props) {
+	        return "jsx-" + baseId;
+	    }
+	    var propsToString = String(props);
+	    var key = baseId + propsToString;
+	    if (!cache[key]) {
+	        cache[key] = "jsx-" + stringHash(baseId + "-" + propsToString);
+	    }
+	    return cache[key];
+	}
+	/**
+	 * computeSelector
+	 *
+	 * Compute and memoize dynamic selectors.
+	 */ function computeSelector(id, css) {
+	    var selectoPlaceholderRegexp = /__jsx-style-dynamic-selector/g;
+	    // Sanitize SSR-ed CSS.
+	    // Client side code doesn't need to be sanitized since we use
+	    // document.createTextNode (dev) and the CSSOM api sheet.insertRule (prod).
+	    if (typeof window === "undefined") {
+	        css = sanitize(css);
+	    }
+	    var idcss = id + css;
+	    if (!cache[idcss]) {
+	        cache[idcss] = css.replace(selectoPlaceholderRegexp, id);
+	    }
+	    return cache[idcss];
+	}
+
+	function mapRulesToStyle(cssRules, options) {
+	    if (options === void 0) options = {};
+	    return cssRules.map(function(args) {
+	        var id = args[0];
+	        var css = args[1];
+	        return /*#__PURE__*/ React__default["default"].createElement("style", {
+	            id: "__" + id,
+	            // Avoid warnings upon render with a key
+	            key: "__" + id,
+	            nonce: options.nonce ? options.nonce : undefined,
+	            dangerouslySetInnerHTML: {
+	                __html: css
+	            }
+	        });
+	    });
+	}
+	var StyleSheetRegistry = /*#__PURE__*/ function() {
+	    function StyleSheetRegistry(param) {
+	        var ref = param === void 0 ? {} : param, _styleSheet = ref.styleSheet, styleSheet = _styleSheet === void 0 ? null : _styleSheet, _optimizeForSpeed = ref.optimizeForSpeed, optimizeForSpeed = _optimizeForSpeed === void 0 ? false : _optimizeForSpeed;
+	        this._sheet = styleSheet || new StyleSheet({
+	            name: "styled-jsx",
+	            optimizeForSpeed: optimizeForSpeed
+	        });
+	        this._sheet.inject();
+	        if (styleSheet && typeof optimizeForSpeed === "boolean") {
+	            this._sheet.setOptimizeForSpeed(optimizeForSpeed);
+	            this._optimizeForSpeed = this._sheet.isOptimizeForSpeed();
+	        }
+	        this._fromServer = undefined;
+	        this._indices = {};
+	        this._instancesCounts = {};
+	    }
+	    var _proto = StyleSheetRegistry.prototype;
+	    _proto.add = function add(props) {
+	        var _this = this;
+	        if (undefined === this._optimizeForSpeed) {
+	            this._optimizeForSpeed = Array.isArray(props.children);
+	            this._sheet.setOptimizeForSpeed(this._optimizeForSpeed);
+	            this._optimizeForSpeed = this._sheet.isOptimizeForSpeed();
+	        }
+	        if (typeof window !== "undefined" && !this._fromServer) {
+	            this._fromServer = this.selectFromServer();
+	            this._instancesCounts = Object.keys(this._fromServer).reduce(function(acc, tagName) {
+	                acc[tagName] = 0;
+	                return acc;
+	            }, {});
+	        }
+	        var ref = this.getIdAndRules(props), styleId = ref.styleId, rules = ref.rules;
+	        // Deduping: just increase the instances count.
+	        if (styleId in this._instancesCounts) {
+	            this._instancesCounts[styleId] += 1;
+	            return;
+	        }
+	        var indices = rules.map(function(rule) {
+	            return _this._sheet.insertRule(rule);
+	        })// Filter out invalid rules
+	        .filter(function(index) {
+	            return index !== -1;
+	        });
+	        this._indices[styleId] = indices;
+	        this._instancesCounts[styleId] = 1;
+	    };
+	    _proto.remove = function remove(props) {
+	        var _this = this;
+	        var styleId = this.getIdAndRules(props).styleId;
+	        invariant(styleId in this._instancesCounts, "styleId: `" + styleId + "` not found");
+	        this._instancesCounts[styleId] -= 1;
+	        if (this._instancesCounts[styleId] < 1) {
+	            var tagFromServer = this._fromServer && this._fromServer[styleId];
+	            if (tagFromServer) {
+	                tagFromServer.parentNode.removeChild(tagFromServer);
+	                delete this._fromServer[styleId];
+	            } else {
+	                this._indices[styleId].forEach(function(index) {
+	                    return _this._sheet.deleteRule(index);
+	                });
+	                delete this._indices[styleId];
+	            }
+	            delete this._instancesCounts[styleId];
+	        }
+	    };
+	    _proto.update = function update(props, nextProps) {
+	        this.add(nextProps);
+	        this.remove(props);
+	    };
+	    _proto.flush = function flush() {
+	        this._sheet.flush();
+	        this._sheet.inject();
+	        this._fromServer = undefined;
+	        this._indices = {};
+	        this._instancesCounts = {};
+	    };
+	    _proto.cssRules = function cssRules() {
+	        var _this = this;
+	        var fromServer = this._fromServer ? Object.keys(this._fromServer).map(function(styleId) {
+	            return [
+	                styleId,
+	                _this._fromServer[styleId]
+	            ];
+	        }) : [];
+	        var cssRules = this._sheet.cssRules();
+	        return fromServer.concat(Object.keys(this._indices).map(function(styleId) {
+	            return [
+	                styleId,
+	                _this._indices[styleId].map(function(index) {
+	                    return cssRules[index].cssText;
+	                }).join(_this._optimizeForSpeed ? "" : "\n")
+	            ];
+	        })// filter out empty rules
+	        .filter(function(rule) {
+	            return Boolean(rule[1]);
+	        }));
+	    };
+	    _proto.styles = function styles(options) {
+	        return mapRulesToStyle(this.cssRules(), options);
+	    };
+	    _proto.getIdAndRules = function getIdAndRules(props) {
+	        var css = props.children, dynamic = props.dynamic, id = props.id;
+	        if (dynamic) {
+	            var styleId = computeId(id, dynamic);
+	            return {
+	                styleId: styleId,
+	                rules: Array.isArray(css) ? css.map(function(rule) {
+	                    return computeSelector(styleId, rule);
+	                }) : [
+	                    computeSelector(styleId, css)
+	                ]
+	            };
+	        }
+	        return {
+	            styleId: computeId(id),
+	            rules: Array.isArray(css) ? css : [
+	                css
+	            ]
+	        };
+	    };
+	    /**
+	   * selectFromServer
+	   *
+	   * Collects style tags from the document with id __jsx-XXX
+	   */ _proto.selectFromServer = function selectFromServer() {
+	        var elements = Array.prototype.slice.call(document.querySelectorAll('[id^="__jsx-"]'));
+	        return elements.reduce(function(acc, element) {
+	            var id = element.id.slice(2);
+	            acc[id] = element;
+	            return acc;
+	        }, {});
+	    };
+	    return StyleSheetRegistry;
+	}();
+	function invariant(condition, message) {
+	    if (!condition) {
+	        throw new Error("StyleSheetRegistry: " + message + ".");
+	    }
+	}
+	var StyleSheetContext = /*#__PURE__*/ React$1.createContext(null);
+	StyleSheetContext.displayName = "StyleSheetContext";
+	function createStyleRegistry() {
+	    return new StyleSheetRegistry();
+	}
+	function StyleRegistry(param) {
+	    var configuredRegistry = param.registry, children = param.children;
+	    var rootRegistry = React$1.useContext(StyleSheetContext);
+	    var ref = React$1.useState(function() {
+	        return rootRegistry || configuredRegistry || createStyleRegistry();
+	    }), registry = ref[0];
+	    return /*#__PURE__*/ React__default["default"].createElement(StyleSheetContext.Provider, {
+	        value: registry
+	    }, children);
+	}
+	function useStyleRegistry() {
+	    return React$1.useContext(StyleSheetContext);
+	}
+
+	// Opt-into the new `useInsertionEffect` API in React 18, fallback to `useLayoutEffect`.
+	// https://github.com/reactwg/react-18/discussions/110
+	var useInsertionEffect = React__default["default"].useInsertionEffect || React$1.useLayoutEffect;
+	var defaultRegistry = typeof window !== "undefined" ? createStyleRegistry() : undefined;
+	function JSXStyle(props) {
+	    var registry = defaultRegistry ? defaultRegistry : useStyleRegistry();
+	    var insertionEffectCalled = React$1.useRef(false);
+	    // `registry` might not exist while server-side rendering
+	    if (!registry) {
+	        return null;
+	    }
+	    if (typeof window === "undefined") {
+	        registry.add(props);
+	        return null;
+	    }
+	    useInsertionEffect(function() {
+	        // ReactDOM removes all DOM during hydration in certain cases
+	        if (!document.head) {
+	            return;
+	        }
+	        registry.add(props);
+	        insertionEffectCalled.current = true;
+	        return function() {
+	            insertionEffectCalled.current = false;
+	            registry.remove(props);
+	        };
+	    }, [
+	        props.id,
+	        String(props.dynamic)
+	    ]);
+	    React$1.useLayoutEffect(function() {
+	        if (!document.head || insertionEffectCalled.current) {
+	            return;
+	        }
+	        registry.add(props);
+	        return function() {
+	            registry.remove(props);
+	        };
+	    // props.children can be string[], will be striped since id is identical
+	    }, [
+	        props.id,
+	        String(props.dynamic)
+	    ]);
+	    return null;
+	}
+	JSXStyle.dynamic = function(info) {
+	    return info.map(function(tagInfo) {
+	        var baseId = tagInfo[0];
+	        var props = tagInfo[1];
+	        return computeId(baseId, props);
+	    }).join(" ");
+	};
+
+	index.StyleRegistry = StyleRegistry;
+	index.createStyleRegistry = createStyleRegistry;
+	index.style = JSXStyle;
+	index.useStyleRegistry = useStyleRegistry;
+	return index;
+}
+
+var style;
+var hasRequiredStyle;
+
+function requireStyle () {
+	if (hasRequiredStyle) return style;
+	hasRequiredStyle = 1;
+	style = requireIndex().style;
+	return style;
+}
+
+var styleExports = requireStyle();
+var _JSXStyle = /*@__PURE__*/getDefaultExportFromCjs(styleExports);
+
+var Notetip = function Notetip(_ref) {
+  var children = _ref.children,
+    text = _ref.text,
+    _ref$placement = _ref.placement,
+    placement = _ref$placement === void 0 ? 'top' : _ref$placement,
+    _ref$delay = _ref.delay,
+    delay = _ref$delay === void 0 ? 0 : _ref$delay,
+    _ref$duration = _ref.duration,
+    duration = _ref$duration === void 0 ? 200 : _ref$duration,
+    _ref$animation = _ref.animation,
+    animation = _ref$animation === void 0 ? 'fade' : _ref$animation;
+  var theme$1 = theme.useTheme();
+  var _useState = React.useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    open = _useState2[0],
+    setOpen = _useState2[1];
+  var _useState3 = React.useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    show = _useState4[0],
+    setShow = _useState4[1];
+  var arrowRef = React.useRef(null);
+  var _useFloating = reactDom.useFloating({
+      placement: placement,
+      middleware: [reactDom.offset(8), reactDom.flip(), reactDom.shift({
+        padding: 5
+      }), reactDom.arrow({
+        element: arrowRef
+      })]
+    }),
+    x = _useFloating.x,
+    y = _useFloating.y,
+    refs = _useFloating.refs,
+    strategy = _useFloating.strategy;
+  React.useEffect(function () {
+    var timer;
+    if (open) {
+      timer = setTimeout(function () {
+        return setShow(true);
+      }, delay);
+    } else {
+      setShow(false);
+    }
+    return function () {
+      return clearTimeout(timer);
+    };
+  }, [open, delay]);
+  var handleMouseEnter = function handleMouseEnter() {
+    return setOpen(true);
+  };
+  var handleMouseLeave = function handleMouseLeave() {
+    return setOpen(false);
+  };
+  var handleTouchStart = function handleTouchStart() {
+    setOpen(true);
+    setTimeout(function () {
+      return setOpen(false);
+    }, 2000); // auto-hide
+  };
+
+  // const staticSide = {
+  //   top: 'bottom',
+  //   right: 'left',
+  //   bottom: 'top',
+  //   left: 'right',
+  // }[finalPlacement.split('-')[0]];
+
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+    ref: refs.setReference,
+    onMouseEnter: handleMouseEnter,
+    onMouseLeave: handleMouseLeave,
+    onTouchStart: handleTouchStart,
+    className: _JSXStyle.dynamic([["4210526695", [theme$1.palette.accents_1, duration, duration, duration]]]) + " " + "tooltip-reference"
+  }, children), show && x != null && y != null && text != null ? /*#__PURE__*/reactDom$1.createPortal(/*#__PURE__*/React.createElement("div", {
+    ref: refs.setFloating,
+    style: {
+      position: strategy,
+      top: y !== null && y !== void 0 ? y : 0,
+      left: x !== null && x !== void 0 ? x : 0,
+      zIndex: 9999,
+      // opacity: show ? 1 : 0,
+      // visibility: x == null || y == null ? 'hidden' : 'visible',
+      transitionProperty: 'opacity, transform',
+      transitionDuration: "".concat(duration, "ms")
+    },
+    className: _JSXStyle.dynamic([["4210526695", [theme$1.palette.accents_1, duration, duration, duration]]]) + " " + "tooltip-box ".concat(animation)
+  }, text), document.body) : null, /*#__PURE__*/React.createElement(_JSXStyle, {
+    id: "4210526695",
+    dynamic: [theme$1.palette.accents_1, duration, duration, duration]
+  }, ".tooltip-box.__jsx-style-dynamic-selector{background:".concat(theme$1.palette.accents_1, ";padding:4px 10px;border-radius:4px;font-size:12px;white-space:nowrap;z-index:9999;opacity:0;}.fade.__jsx-style-dynamic-selector{-webkit-animation:fadeIn-__jsx-style-dynamic-selector ").concat(duration, "ms ease forwards;animation:fadeIn-__jsx-style-dynamic-selector ").concat(duration, "ms ease forwards;}@-webkit-keyframes fadeIn-__jsx-style-dynamic-selector{from{opacity:0;}to{opacity:1;}}@keyframes fadeIn-__jsx-style-dynamic-selector{from{opacity:0;}to{opacity:1;}}.scale.__jsx-style-dynamic-selector{-webkit-animation:scaleIn-__jsx-style-dynamic-selector ").concat(duration, "ms ease forwards;animation:scaleIn-__jsx-style-dynamic-selector ").concat(duration, "ms ease forwards;}@-webkit-keyframes scaleIn-__jsx-style-dynamic-selector{from{opacity:0;-webkit-transform:scale(0.95);-ms-transform:scale(0.95);transform:scale(0.95);}to{opacity:1;-webkit-transform:scale(1);-ms-transform:scale(1);transform:scale(1);}}@keyframes scaleIn-__jsx-style-dynamic-selector{from{opacity:0;-webkit-transform:scale(0.95);-ms-transform:scale(0.95);transform:scale(0.95);}to{opacity:1;-webkit-transform:scale(1);-ms-transform:scale(1);transform:scale(1);}}.slide.__jsx-style-dynamic-selector{-webkit-animation:slideIn-__jsx-style-dynamic-selector ").concat(duration, "ms ease forwards;animation:slideIn-__jsx-style-dynamic-selector ").concat(duration, "ms ease forwards;}@-webkit-keyframes slideIn-__jsx-style-dynamic-selector{from{opacity:0;-webkit-transform:translateY(5px);-ms-transform:translateY(5px);transform:translateY(5px);}to{opacity:1;-webkit-transform:translateY(0);-ms-transform:translateY(0);transform:translateY(0);}}@keyframes slideIn-__jsx-style-dynamic-selector{from{opacity:0;-webkit-transform:translateY(5px);-ms-transform:translateY(5px);transform:translateY(5px);}to{opacity:1;-webkit-transform:translateY(0);-ms-transform:translateY(0);transform:translateY(0);}}")));
+};
+
+exports.default = Notetip;

package/{esm/notetip/index.d.ts → dist/notetip/note-tip.d.ts}

@@ -9,5 +9,5 @@ export type NotetipProps = {
     duration?: number;
     animation?: AnimationVariant;
 };
-declare const Tooltip: React.FC<NotetipProps>;
-export default Tooltip;
+declare const Notetip: React.FC<NotetipProps>;
+export default Notetip;