@hanzogui/tooltip 7.0.0 → 7.3.0

package/LICENSE

@@ -1,21 +1,42 @@
-MIT License
+BSD 3-Clause License
+
+Copyright (c) 2026-present, Hanzo AI, Inc.
+
+Portions of this software are derived from upstream code originally licensed under
+the MIT License, with the following copyright notices retained per its terms:
 
   Copyright (c) 2020 Nate Wienert
-  
-  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.
+  Copyright (c) 2015-present, Nicolas Gallagher.
+  Copyright (c) 2015-present, Facebook, Inc.
+  Copyright (c) 2021 Radix
+  Copyright (c) 2017 Carmelo Pullara
+  Copyright (c) 2018 Framer B.V.
+  Copyright (c) 2022 WorkOS
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

package/dist/cjs/Tooltip.cjs

@@ -0,0 +1,241 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var Tooltip_exports = {};
+__export(Tooltip_exports, {
+  Tooltip: () => Tooltip2,
+  TooltipGroup: () => TooltipGroup,
+  closeOpenTooltips: () => closeOpenTooltips
+});
+module.exports = __toCommonJS(Tooltip_exports);
+var import_polyfill_dev = require("@hanzogui/polyfill-dev");
+var import_floating = require("@hanzogui/floating");
+var import_core = require("@hanzogui/core");
+var import_floating2 = require("@hanzogui/floating");
+var import_get_token = require("@hanzogui/get-token");
+var import_helpers = require("@hanzogui/helpers");
+var import_popover = require("@hanzogui/popover");
+var import_popper = require("@hanzogui/popper");
+var import_use_controllable_state = require("@hanzogui/use-controllable-state");
+var React = __toESM(require("react"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+const TOOLTIP_SCOPE = "";
+const ALWAYS_DISABLE_TOOLTIP = {
+  focus: true,
+  "remove-scroll": true
+  // it's nice to hit escape to hide a tooltip
+  // dismiss: true
+};
+const TooltipContent = import_popper.PopperContentFrame.styleable((props, ref) => {
+  const preventAnimation = React.useContext(PreventTooltipAnimationContext);
+  const zIndexFromContext = React.useContext(TooltipZIndexContext);
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_popover.PopoverContent, {
+    scope: props.scope || TOOLTIP_SCOPE,
+    alwaysDisable: ALWAYS_DISABLE_TOOLTIP,
+    ...(!props.unstyled && {
+      backgroundColor: "$background",
+      alignItems: "center",
+      pointerEvents: "none",
+      size: "$true"
+    }),
+    ref,
+    ...(zIndexFromContext !== void 0 && {
+      zIndex: zIndexFromContext
+    }),
+    ...props,
+    ...(preventAnimation && {
+      transition: null
+    })
+  });
+}, {
+  staticConfig: {
+    componentName: "Tooltip"
+  }
+});
+const TooltipArrow = React.forwardRef((props, ref) => {
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_popover.PopoverArrow, {
+    scope: props.scope || TOOLTIP_SCOPE,
+    componentName: "Tooltip",
+    ref,
+    ...props
+  });
+});
+const PreventTooltipAnimationContext = React.createContext(false);
+const TooltipZIndexContext = React.createContext(void 0);
+const TooltipGroup = ({
+  children,
+  delay,
+  preventAnimation = false,
+  timeoutMs
+}) => {
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(PreventTooltipAnimationContext.Provider, {
+    value: preventAnimation,
+    children: /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_floating.FloatingDelayGroup, {
+      timeoutMs,
+      delay: React.useMemo(() => delay, [JSON.stringify(delay)]),
+      children
+    })
+  });
+};
+const setOpens = /* @__PURE__ */new Set();
+const closeOpenTooltips = () => {
+  setOpens.forEach(x => x(false));
+};
+const TooltipComponent = React.forwardRef(function Tooltip(props, ref) {
+  "use no memo";
+
+  const {
+    children,
+    delay: delayProp,
+    restMs: restMsProp,
+    onOpenChange: onOpenChangeProp,
+    focus,
+    open: openProp,
+    disableAutoCloseOnScroll,
+    zIndex,
+    scope = TOOLTIP_SCOPE,
+    ...restProps
+  } = props;
+  const triggerRef = React.useRef(null);
+  const [hasCustomAnchor, setHasCustomAnchor] = React.useState(false);
+  const {
+    delay: delayGroup,
+    setCurrentId
+  } = (0, import_floating.useDelayGroupContext)();
+  const delay = delayProp !== void 0 ? delayProp : delayGroup ?? 400;
+  const restMs = restMsProp ?? (typeof delay === "number" ? delay : 0);
+  const [open, setOpen] = (0, import_use_controllable_state.useControllableState)({
+    prop: openProp,
+    defaultProp: false,
+    onChange: onOpenChangeProp
+  });
+  const id = props.groupId;
+  const onOpenChange = (0, import_core.useEvent)(open2 => {
+    if (open2) {
+      setCurrentId(id);
+    }
+    setOpen(open2);
+  });
+  React.useEffect(() => {
+    if (!open) return;
+    if (disableAutoCloseOnScroll) return;
+    if (typeof document === "undefined") return;
+    const closeIt = () => {
+      setOpen(false);
+    };
+    setOpens.add(setOpen);
+    document.documentElement.addEventListener("scroll", closeIt);
+    return () => {
+      setOpens.delete(setOpen);
+      document.documentElement.removeEventListener("scroll", closeIt);
+    };
+  }, [open, disableAutoCloseOnScroll]);
+  const floatingContext = (0, import_popover.useFloatingContext)({
+    open,
+    setOpen: onOpenChange,
+    disable: false,
+    disableFocus: false,
+    hoverable: true,
+    role: "tooltip",
+    focus,
+    groupId: id,
+    delay,
+    restMs
+  });
+  const onCustomAnchorAdd = React.useCallback(() => setHasCustomAnchor(true), []);
+  const onCustomAnchorRemove = React.useCallback(() => setHasCustomAnchor(false), []);
+  const contentId = React.useId();
+  const smallerSize = props.unstyled ? null : (0, import_get_token.getSize)("$true", {
+    shift: -2,
+    bounds: [0]
+  });
+  const content = /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_floating2.FloatingOverrideContext.Provider, {
+    value: floatingContext,
+    children: /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_popper.Popper, {
+      scope,
+      size: smallerSize?.key,
+      allowFlip: true,
+      stayInFrame: true,
+      open,
+      ...restProps,
+      children: /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_popover.PopoverContextProvider, {
+        scope,
+        contentId,
+        triggerRef,
+        open,
+        onOpenChange: setOpen,
+        onOpenToggle: voidFn,
+        hasCustomAnchor,
+        onCustomAnchorAdd,
+        onCustomAnchorRemove,
+        children
+      })
+    })
+  });
+  if (zIndex !== void 0) {
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(TooltipZIndexContext.Provider, {
+      value: zIndex,
+      children: content
+    });
+  }
+  return content;
+});
+const TooltipTrigger = React.forwardRef(function TooltipTrigger2(props, ref) {
+  const {
+    scope,
+    ...rest
+  } = props;
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_popover.PopoverTrigger, {
+    ...rest,
+    scope: scope || TOOLTIP_SCOPE,
+    ref
+  });
+});
+const TooltipAnchor = React.forwardRef(function TooltipAnchor2(props, ref) {
+  const {
+    scope,
+    ...rest
+  } = props;
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_popover.PopoverAnchor, {
+    ...rest,
+    scope: scope || TOOLTIP_SCOPE,
+    ref
+  });
+});
+const Tooltip2 = (0, import_helpers.withStaticProperties)(TooltipComponent, {
+  Anchor: TooltipAnchor,
+  Arrow: TooltipArrow,
+  Content: TooltipContent,
+  Trigger: TooltipTrigger
+});
+const voidFn = () => {};

package/dist/cjs/Tooltip.native.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var Tooltip_native_exports = {};
+__export(Tooltip_native_exports, {
+  Tooltip: () => Tooltip,
+  TooltipGroup: () => TooltipGroup,
+  closeOpenTooltips: () => closeOpenTooltips
+});
+module.exports = __toCommonJS(Tooltip_native_exports);
+var import_helpers = require("@hanzogui/helpers");
+var RenderChildren = function (props) {
+  return props.children;
+};
+var RenderNull = function (props) {
+  return null;
+};
+var TooltipGroup = function () {
+  return null;
+};
+var closeOpenTooltips = function () {};
+var Tooltip = (0, import_helpers.withStaticProperties)(RenderChildren, {
+  Anchor: RenderChildren,
+  Arrow: RenderNull,
+  Close: RenderNull,
+  Content: RenderNull,
+  Trigger: RenderChildren
+});
+//# sourceMappingURL=Tooltip.native.js.map

package/dist/cjs/Tooltip.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Tooltip_native_exports","__export","Tooltip","TooltipGroup","closeOpenTooltips","module","exports","__toCommonJS","import_helpers","require","RenderChildren","props","children","RenderNull","withStaticProperties","Anchor","Arrow","Close","Content","Trigger"],"sources":["../../src/Tooltip.native.tsx"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,sBAAA;AAAAC,QAAA,CAAAD,sBAAA;EAAAE,OAAA,EAAAA,CAAA,KAAAA,OAAA;EAAAC,YAAA,EAAAA,CAAA,KAAAA,YAAA;EAAAC,iBAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAC,YAAA,CAAAP,sBAAA;AAAA,IAAAQ,cAAA,GAAqCC,OAAA;AAGrC,IAAIC,cAAA,GAAiB,SAAAA,CAASC,KAAA,EAAO;EACjC,OAAOA,KAAA,CAAMC,QAAA;AACjB;AACA,IAAIC,UAAA,GAAa,SAAAA,CAASF,KAAA,EAAO;EAC7B,OAAO;AACX;AACO,IAAIR,YAAA,GAAe,SAAAA,CAAA,EAAW;EACjC,OAAO;AACX;AACO,IAAIC,iBAAA,GAAoB,SAAAA,CAAA,EAAW,CAAC;AACzB,IAAIF,OAAA,OAAUM,cAAA,CAAAM,oBAAA,EAAqBJ,cAAA,EAAgB;EACjEK,MAAA,EAAQL,cAAA;EACRM,KAAA,EAAOH,UAAA;EACPI,KAAA,EAAOJ,UAAA;EACPK,OAAA,EAASL,UAAA;EACTM,OAAA,EAAST;AACb,CAAC","ignoreList":[]}

package/dist/cjs/TooltipSimple.cjs

@@ -0,0 +1,112 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var TooltipSimple_exports = {};
+__export(TooltipSimple_exports, {
+  TooltipSimple: () => TooltipSimple
+});
+module.exports = __toCommonJS(TooltipSimple_exports);
+var import_get_token = require("@hanzogui/get-token");
+var import_text = require("@hanzogui/text");
+var React = __toESM(require("react"), 1);
+var import_Tooltip = require("./Tooltip.cjs");
+var import_jsx_runtime = require("react/jsx-runtime");
+const TooltipSimple = React.forwardRef(({
+  label,
+  children,
+  contentProps,
+  disabled,
+  ...tooltipProps
+}, ref) => {
+  "use no memo";
+
+  const child = React.Children.only(children);
+  if (!label) {
+    return children;
+  }
+  return /* @__PURE__ */(0, import_jsx_runtime.jsxs)(import_Tooltip.Tooltip, {
+    disableRTL: true,
+    offset: 15,
+    restMs: 40,
+    delay: 40,
+    zIndex: 1e6,
+    ...tooltipProps,
+    ...(disabled ? {
+      open: false
+    } : null),
+    children: [/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_Tooltip.Tooltip.Trigger, {
+      ...(typeof label === "string" && {
+        "aria-label": label
+      }),
+      asChild: "except-style",
+      children: ref && React.isValidElement(child) ? React.cloneElement(child, {
+        ref
+      }) : child
+    }), /* @__PURE__ */(0, import_jsx_runtime.jsxs)(import_Tooltip.Tooltip.Content, {
+      enterStyle: {
+        y: -4,
+        opacity: 0,
+        scale: 0.96
+      },
+      exitStyle: {
+        y: -4,
+        opacity: 0,
+        scale: 0.96
+      },
+      scale: 1,
+      elevation: "$0.5",
+      opacity: 1,
+      pointerEvents: "none",
+      paddingVertical: (0, import_get_token.getSpace)(tooltipProps.size || "$true", {
+        shift: -4
+      }),
+      animateOnly: ["transform", "opacity"],
+      transition: ["quicker", {
+        opacity: {
+          overshootClamping: true
+        }
+      }],
+      ...contentProps,
+      children: [/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_Tooltip.Tooltip.Arrow, {}), /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_text.Paragraph, {
+        maxWidth: 350,
+        overflow: "hidden",
+        size: "$3",
+        textAlign: "center",
+        "$platform-web": {
+          textWrap: "balance"
+        },
+        children: label
+      })]
+    })]
+  });
+});

package/dist/cjs/TooltipSimple.native.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var TooltipSimple_native_exports = {};
+__export(TooltipSimple_native_exports, {
+  TooltipSimple: () => TooltipSimple
+});
+module.exports = __toCommonJS(TooltipSimple_native_exports);
+var RenderChildren = function (props) {
+  return props.children;
+};
+var TooltipSimple = RenderChildren;
+//# sourceMappingURL=TooltipSimple.native.js.map

package/dist/cjs/TooltipSimple.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TooltipSimple_native_exports","__export","TooltipSimple","module","exports","__toCommonJS","RenderChildren","props","children"],"sources":["../../src/TooltipSimple.native.tsx"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,4BAAA;AAAAC,QAAA,CAAAD,4BAAA;EAAAE,aAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAC,YAAA,CAAAL,4BAAA;AAAA,IAAIM,cAAA,GAAiB,SAAAA,CAASC,KAAA,EAAO;EACjC,OAAOA,KAAA,CAAMC,QAAA;AACjB;AACO,IAAIN,aAAA,GAAgBI,cAAA","ignoreList":[]}

package/dist/cjs/index.cjs

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./Tooltip.cjs"), module.exports);
+__reExport(index_exports, require("./TooltipSimple.cjs"), module.exports);

package/dist/cjs/index.native.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./Tooltip.native.js"), module.exports);
+__reExport(index_exports, require("./TooltipSimple.native.js"), module.exports);
+//# sourceMappingURL=index.native.js.map

package/dist/cjs/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","index_exports","module","exports","__reExport","require"],"sources":["../../src/index.tsx"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,aAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAP,YAAc,CAAAK,aAAA;AACdG,UAAA,CAAAH,aAAA,EAAcI,OAAA,yBAAAH,MADd,CAAAC,OAAA","ignoreList":[]}