@elliemae/ds-legacy-tooltip 1.0.0-rc.1

package/dist/cjs/index.js

@@ -0,0 +1,43 @@
+"use strict";
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 src_exports = {};
+__export(src_exports, {
+  default: () => import_DSTooltip.default,
+  tooltipPositions: () => import_tooltipPositions.tooltipPositions
+});
+module.exports = __toCommonJS(src_exports);
+var React = __toESM(require("react"));
+__reExport(src_exports, require("./v1/DSTooltip.js"), module.exports);
+__reExport(src_exports, require("./v2/DSTooltip.js"), module.exports);
+var import_tooltipPositions = require("./v2/utils/tooltipPositions.js");
+__reExport(src_exports, require("./v2/TooltipType.js"), module.exports);
+__reExport(src_exports, require("./v3/index.js"), module.exports);
+var import_DSTooltip = __toESM(require("./v1/DSTooltip.js"));
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export * from './v1/DSTooltip.js';\nexport * from './v2/DSTooltip.js';\nexport { tooltipPositions } from './v2/utils/tooltipPositions.js';\nexport * from './v2/TooltipType.js';\nexport * from './v3/index.js';\nexport { default } from './v1/DSTooltip.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,wBAAc,8BAAd;AACA,wBAAc,8BADd;AAEA,8BAAiC;AACjC,wBAAc,gCAHd;AAIA,wBAAc,0BAJd;AAKA,uBAAwB;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,7 @@
+{
+  "type": "commonjs",
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ]
+}

package/dist/cjs/v1/DSTooltip.js

@@ -0,0 +1,130 @@
+"use strict";
+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 DSTooltip_exports = {};
+__export(DSTooltip_exports, {
+  DSTooltip: () => DSTooltip,
+  TooltipContainer: () => TooltipContainer,
+  TooltipText: () => TooltipText,
+  TooltipWithSchema: () => TooltipWithSchema,
+  default: () => DSTooltip_default
+});
+module.exports = __toCommonJS(DSTooltip_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_ds_legacy_classnames = require("@elliemae/ds-legacy-classnames");
+var import_ds_legacy_utilities = require("@elliemae/ds-legacy-utilities");
+var import_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+var import_ds_legacy_shared = require("@elliemae/ds-legacy-shared");
+var import_ds_legacy_popper = require("@elliemae/ds-legacy-popper");
+var import_TooltipType = require("./TooltipType.js");
+const blockName = "tooltip";
+const TooltipContainer = (0, import_ds_legacy_classnames.aggregatedClasses)("div")(blockName, false, false, {
+  propsToRemoveFromFinalElement: ["isHovered", "isDragged"]
+});
+const TooltipText = (0, import_ds_legacy_classnames.aggregatedClasses)("span")(blockName, "text", false, {
+  propsToRemoveFromFinalElement: ["isHovered", "isDragged"]
+});
+const DSTooltip = ({
+  containerProps = {},
+  innerRef,
+  placement = import_ds_legacy_popper.PopperPositions.TOP,
+  title = "",
+  delayClose = import_ds_legacy_shared.DEFAULT_DELAY_CLOSE,
+  delayOpen = import_ds_legacy_shared.DEFAULT_DELAY_OPEN,
+  interactionType = import_ds_legacy_popper.PopperInteractions.HOVER,
+  triggerComponent = null,
+  className = "",
+  isOpen = void 0,
+  onOpen = () => null,
+  springAnimationComponent = void 0,
+  tooltipType = import_TooltipType.TooltipType.TOOLTIP,
+  showArrow = true,
+  zIndex,
+  ...otherTooltipProps
+}) => {
+  (0, import_ds_legacy_utilities.useDeprecateComponent)({ componentName: "ds-tooltip", version: "TBD Date: 2023 Q3" });
+  const { cssClassName: tooltipBlockName } = (0, import_ds_legacy_classnames.convertPropToCssClassName)(blockName);
+  let Content = title;
+  if (typeof title === "string") {
+    Content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TooltipText, { children: title });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_ds_legacy_popper.DSPopper,
+    {
+      blockName: tooltipBlockName,
+      contentComponent: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        TooltipContainer,
+        {
+          ...containerProps,
+          ...otherTooltipProps,
+          className: `tooltip-container--${tooltipType} ${className}`,
+          innerRef,
+          children: Content
+        }
+      ),
+      delayClose,
+      delayOpen,
+      interactionType,
+      isOpen,
+      onOpen,
+      placement,
+      showArrow: tooltipType === import_TooltipType.TooltipType.TOOLTIP ? showArrow : false,
+      springAnimationComponent,
+      triggerComponent: (0, import_ds_legacy_utilities.getComponentFromProps)(triggerComponent),
+      zIndex
+    }
+  );
+};
+const tooltipProps = {
+  containerProps: import_ds_legacy_props_helpers.PropTypes.object.description("Set of Properties attached to the main container"),
+  placement: import_ds_legacy_props_helpers.PropTypes.oneOf(import_ds_legacy_popper.positions).description("Tooltip position").defaultValue(import_ds_legacy_popper.PopperPositions.TOP),
+  title: import_ds_legacy_props_helpers.PropTypes.oneOfType([import_ds_legacy_props_helpers.PropTypes.string, import_ds_legacy_props_helpers.PropTypes.element]).description("Tooltip content").isRequired,
+  delayClose: import_ds_legacy_props_helpers.PropTypes.string.description("Delay to close the tooltip").defaultValue(import_ds_legacy_shared.DEFAULT_DELAY_CLOSE),
+  delayOpen: import_ds_legacy_props_helpers.PropTypes.string.description("Delay to open the tooltip ").defaultValue(import_ds_legacy_shared.DEFAULT_DELAY_OPEN),
+  interactionType: import_ds_legacy_props_helpers.PropTypes.oneOf(import_ds_legacy_popper.interactions).description("A type indicating how to open/close the tooltip").defaultValue(import_ds_legacy_popper.PopperInteractions.HOVER),
+  triggerComponent: import_ds_legacy_props_helpers.PropTypes.element.description(
+    `The component that will open/close the tooltip. 
+    Cannot be used with disabled elements. 
+    https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/disabled`
+  ).isRequired,
+  isOpen: import_ds_legacy_props_helpers.PropTypes.bool.description("Whether the tooltip is visible or not").defaultValue(void 0),
+  onOpen: import_ds_legacy_props_helpers.PropTypes.func.description("Handler when the tooltip opens"),
+  springAnimationComponent: import_ds_legacy_props_helpers.PropTypes.element.description("Spring animation component"),
+  showArrow: import_ds_legacy_props_helpers.PropTypes.bool.description("Whether to show an arrow or not").defaultValue(true),
+  className: import_ds_legacy_props_helpers.PropTypes.string.description("css class"),
+  tooltipType: import_ds_legacy_props_helpers.PropTypes.oneOf(["tooltip", "toolbar"]).description("Type of tooltip").defaultValue(import_TooltipType.TooltipType.TOOLTIP),
+  zIndex: import_ds_legacy_props_helpers.PropTypes.number.description("z-index value assigned to the tooltip").defaultValue(void 0),
+  innerRef: import_ds_legacy_props_helpers.PropTypes.oneOfType([import_ds_legacy_props_helpers.PropTypes.func, import_ds_legacy_props_helpers.PropTypes.object]).description("Ref to the tooltip container element")
+};
+DSTooltip.propTypes = tooltipProps;
+DSTooltip.displayName = "DSTooltip";
+const TooltipWithSchema = (0, import_ds_legacy_props_helpers.describe)(DSTooltip);
+TooltipWithSchema.propTypes = tooltipProps;
+var DSTooltip_default = DSTooltip;
+//# sourceMappingURL=DSTooltip.js.map

package/dist/cjs/v1/DSTooltip.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/v1/DSTooltip.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable eslint-comments/no-unlimited-disable */\n/* eslint-disable */\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nimport React from 'react';\nimport { aggregatedClasses, convertPropToCssClassName } from '@elliemae/ds-legacy-classnames';\nimport { getComponentFromProps, useDeprecateComponent } from '@elliemae/ds-legacy-utilities';\nimport { describe, PropTypes } from '@elliemae/ds-legacy-props-helpers';\nimport { DEFAULT_DELAY_OPEN, DEFAULT_DELAY_CLOSE } from '@elliemae/ds-legacy-shared';\nimport { DSPopper, PopperPositions, PopperInteractions, interactions, positions } from '@elliemae/ds-legacy-popper';\nimport { TooltipType } from './TooltipType.js';\n\nconst blockName = 'tooltip';\n\nconst TooltipContainer = aggregatedClasses('div')(blockName, false, false, {\n  propsToRemoveFromFinalElement: ['isHovered', 'isDragged'],\n});\nconst TooltipText = aggregatedClasses('span')(blockName, 'text', false, {\n  propsToRemoveFromFinalElement: ['isHovered', 'isDragged'],\n});\n\nconst DSTooltip = ({\n  containerProps = {},\n  innerRef,\n  placement = PopperPositions.TOP,\n  title = '',\n  delayClose = DEFAULT_DELAY_CLOSE,\n  delayOpen = DEFAULT_DELAY_OPEN,\n  interactionType = PopperInteractions.HOVER,\n  triggerComponent = null,\n  className = '',\n  isOpen = undefined,\n  onOpen = () => null,\n  springAnimationComponent = undefined,\n  tooltipType = TooltipType.TOOLTIP,\n  showArrow = true,\n  zIndex,\n  ...otherTooltipProps\n}) => {\n  useDeprecateComponent({ componentName: 'ds-tooltip', version: 'TBD Date: 2023 Q3' });\n\n  const { cssClassName: tooltipBlockName } = convertPropToCssClassName(blockName);\n\n  let Content = title;\n  if (typeof title === 'string') {\n    Content = <TooltipText>{title}</TooltipText>;\n  }\n  return (\n    <DSPopper\n      blockName={tooltipBlockName}\n      contentComponent={\n        <TooltipContainer\n          {...containerProps}\n          {...otherTooltipProps}\n          className={`tooltip-container--${tooltipType} ${className}`}\n          innerRef={innerRef}\n        >\n          {Content}\n        </TooltipContainer>\n      }\n      delayClose={delayClose}\n      delayOpen={delayOpen}\n      interactionType={interactionType}\n      isOpen={isOpen}\n      onOpen={onOpen}\n      placement={placement}\n      showArrow={tooltipType === TooltipType.TOOLTIP ? showArrow : false}\n      springAnimationComponent={springAnimationComponent}\n      triggerComponent={getComponentFromProps(triggerComponent)}\n      zIndex={zIndex}\n    />\n  );\n};\n\nconst tooltipProps = {\n  containerProps: PropTypes.object.description('Set of Properties attached to the main container'),\n  placement: PropTypes.oneOf(positions).description('Tooltip position').defaultValue(PopperPositions.TOP),\n  title: PropTypes.oneOfType([PropTypes.string, PropTypes.element]).description('Tooltip content').isRequired,\n  delayClose: PropTypes.string.description('Delay to close the tooltip').defaultValue(DEFAULT_DELAY_CLOSE),\n  delayOpen: PropTypes.string.description('Delay to open the tooltip ').defaultValue(DEFAULT_DELAY_OPEN),\n  interactionType: PropTypes.oneOf(interactions)\n    .description('A type indicating how to open/close the tooltip')\n    .defaultValue(PopperInteractions.HOVER),\n  triggerComponent: PropTypes.element.description(\n    `The component that will open/close the tooltip. \n    Cannot be used with disabled elements. \n    https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/disabled`,\n  ).isRequired,\n  isOpen: PropTypes.bool.description('Whether the tooltip is visible or not').defaultValue(undefined),\n  onOpen: PropTypes.func.description('Handler when the tooltip opens'),\n  springAnimationComponent: PropTypes.element.description('Spring animation component'),\n  showArrow: PropTypes.bool.description('Whether to show an arrow or not').defaultValue(true),\n  className: PropTypes.string.description('css class'),\n  tooltipType: PropTypes.oneOf(['tooltip', 'toolbar']).description('Type of tooltip').defaultValue(TooltipType.TOOLTIP),\n  zIndex: PropTypes.number.description('z-index value assigned to the tooltip').defaultValue(undefined),\n  innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).description('Ref to the tooltip container element'),\n};\n\nDSTooltip.propTypes = tooltipProps;\nDSTooltip.displayName = 'DSTooltip';\nconst TooltipWithSchema = describe(DSTooltip);\nTooltipWithSchema.propTypes = tooltipProps;\n\nexport { DSTooltip, TooltipContainer, TooltipText, TooltipWithSchema };\nexport default DSTooltip;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/v1/TooltipType.js

@@ -0,0 +1,39 @@
+"use strict";
+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 TooltipType_exports = {};
+__export(TooltipType_exports, {
+  TooltipType: () => TooltipType
+});
+module.exports = __toCommonJS(TooltipType_exports);
+var React = __toESM(require("react"));
+const TooltipType = {
+  TOOLTIP: "tooltip",
+  TOOLBAR: "toolbar"
+};
+//# sourceMappingURL=TooltipType.js.map

package/dist/cjs/v1/TooltipType.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/v1/TooltipType.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable eslint-comments/no-unlimited-disable */\n/* eslint-disable */\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nexport const TooltipType = {\n  TOOLTIP: 'tooltip',\n  TOOLBAR: 'toolbar',\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADIhB,MAAM,cAAc;AAAA,EACzB,SAAS;AAAA,EACT,SAAS;AACX;",
+  "names": []
+}

package/dist/cjs/v2/DSTooltip.js

@@ -0,0 +1,174 @@
+"use strict";
+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 DSTooltip_exports = {};
+__export(DSTooltip_exports, {
+  DSTooltipV2: () => DSTooltipV2,
+  TooltipV2WithSchema: () => TooltipV2WithSchema
+});
+module.exports = __toCommonJS(DSTooltip_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_ds_legacy_utilities = require("@elliemae/ds-legacy-utilities");
+var import_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+var import_ds_legacy_portal = require("@elliemae/ds-legacy-portal");
+var import_ds_legacy_shared = require("@elliemae/ds-legacy-shared");
+var import_react_popper = require("react-popper");
+var import_ds_legacy_system = require("@elliemae/ds-legacy-system");
+var import_tooltipPositions = require("./utils/tooltipPositions.js");
+var import_TooltipType = require("./TooltipType.js");
+var import_styles = require("./styles.js");
+var import_DSTooltipArrow = require("./DSTooltipArrow.js");
+var import_propTypes = require("./propTypes.js");
+var import_setMultipleRefs = require("./utils/setMultipleRefs.js");
+const DSTooltipV2 = ({
+  containerProps = {},
+  innerRef,
+  placement = import_tooltipPositions.tooltipPositions.BOTTOM,
+  title = "",
+  delayClose = import_ds_legacy_shared.DEFAULT_DELAY_CLOSE,
+  delayOpen = import_ds_legacy_shared.DEFAULT_DELAY_OPEN,
+  triggerComponent = null,
+  className = "",
+  getIsOpen = () => null,
+  onOpen = () => null,
+  tooltipType = import_TooltipType.TooltipType.TOOLTIP,
+  showArrow = true,
+  offset = [0, 14],
+  zIndex,
+  extraModifiers = {}
+}) => {
+  (0, import_ds_legacy_utilities.useDeprecateComponent)({ componentName: "ds-tooltip-v2", version: "TBD Date: 2023 Q3" });
+  const [showTooltip, setShowTooltip] = (0, import_react.useState)(false);
+  const [isAnimating, setIsAnimating] = (0, import_react.useState)(false);
+  const [referenceElement, setReferenceElement] = (0, import_react.useState)(triggerComponent);
+  const [popperElement, setPopperElement] = (0, import_react.useState)(null);
+  const [arrowElement, setArrowElement] = (0, import_react.useState)(null);
+  const timerOpen = (0, import_react.useRef)(null);
+  const timerClosed = (0, import_react.useRef)(null);
+  const { styles, attributes } = (0, import_react_popper.usePopper)(referenceElement, popperElement, {
+    placement,
+    modifiers: [
+      { name: "hide", enabled: true },
+      {
+        name: "offset",
+        enabled: true,
+        options: {
+          offset: tooltipType === import_TooltipType.TooltipType.TOOLBAR ? [0, 0] : offset
+        }
+      },
+      { name: "arrow", options: { element: arrowElement } },
+      { ...extraModifiers }
+    ]
+  });
+  const handleShowTooltipOn = (0, import_react.useCallback)(() => {
+    timerOpen.current = setTimeout(() => {
+      setShowTooltip(true);
+      setIsAnimating(true);
+      getIsOpen(true);
+      onOpen();
+    }, delayOpen);
+  }, [delayOpen, getIsOpen, onOpen]);
+  const handleShowTooltipOff = (0, import_react.useCallback)(() => {
+    timerClosed.current = setTimeout(() => {
+      setShowTooltip(false);
+      setIsAnimating(true);
+      getIsOpen(false);
+    }, delayClose);
+  }, [delayClose, getIsOpen]);
+  const handleKeyDown = (0, import_react.useCallback)((e) => {
+    if (e.key === "Escape") {
+      e.target.blur();
+    }
+  }, []);
+  const checkAnimationStatus = (0, import_react.useCallback)(() => {
+    if (!showTooltip) {
+      setIsAnimating(false);
+    }
+  }, [showTooltip]);
+  (0, import_react.useEffect)(
+    () => () => {
+      clearTimeout(timerClosed.current);
+      clearTimeout(timerOpen.current);
+    },
+    []
+  );
+  const theme = (0, import_react.useContext)(import_ds_legacy_system.ThemeContext);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_styles.StyledTriggerComponentContainer,
+      {
+        ref: setReferenceElement,
+        onMouseEnter: handleShowTooltipOn,
+        onMouseLeave: handleShowTooltipOff,
+        onFocus: handleShowTooltipOn,
+        onBlur: handleShowTooltipOff,
+        onKeyDown: handleKeyDown,
+        children: triggerComponent
+      }
+    ),
+    isAnimating || showTooltip ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ds_legacy_portal.DSPortal, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_styles.StyledTooltipContainer,
+      {
+        className,
+        showTooltip,
+        tooltipType,
+        "data-testid": "ds-tooltip-container",
+        ref: (ref) => (0, import_setMultipleRefs.setMultipleRefs)(setPopperElement, innerRef)(ref),
+        style: { ...styles.popper, zIndex: zIndex ?? theme.zIndex.tooltip },
+        ...containerProps,
+        ...attributes.popper,
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+          import_styles.StyledAnimatedTooltip,
+          {
+            showTooltip,
+            "data-testid": "ds-tooltip",
+            onAnimationEnd: checkAnimationStatus,
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_styles.StyledTooltipText, { children: title }),
+              tooltipType === import_TooltipType.TooltipType.TOOLTIP && showArrow ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                import_DSTooltipArrow.DSTooltipArrow,
+                {
+                  arrowElementRef: setArrowElement,
+                  style: styles.arrow,
+                  placement: attributes.popper ? attributes.popper["data-popper-placement"] : "bottom"
+                }
+              ) : null
+            ]
+          }
+        )
+      }
+    ) }) : null
+  ] });
+};
+DSTooltipV2.propTypes = import_propTypes.tooltipV2Props;
+DSTooltipV2.displayName = "DSTooltipV2";
+const TooltipV2WithSchema = (0, import_ds_legacy_props_helpers.describe)(DSTooltipV2);
+TooltipV2WithSchema.propTypes = import_propTypes.tooltipV2Props;
+//# sourceMappingURL=DSTooltip.js.map

package/dist/cjs/v2/DSTooltip.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/v2/DSTooltip.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable eslint-comments/no-unlimited-disable */\n/* eslint-disable */\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nimport React, { useState, useCallback, useEffect, useRef, useContext } from 'react';\nimport { useDeprecateComponent } from '@elliemae/ds-legacy-utilities';\nimport { describe } from '@elliemae/ds-legacy-props-helpers';\nimport { DSPortal } from '@elliemae/ds-legacy-portal';\nimport { DEFAULT_DELAY_OPEN, DEFAULT_DELAY_CLOSE } from '@elliemae/ds-legacy-shared';\nimport { usePopper } from 'react-popper';\nimport { ThemeContext } from '@elliemae/ds-legacy-system';\nimport { tooltipPositions } from './utils/tooltipPositions.js';\nimport { TooltipType } from './TooltipType.js';\nimport {\n  StyledTooltipContainer,\n  StyledTriggerComponentContainer,\n  StyledTooltipText,\n  StyledAnimatedTooltip,\n} from './styles.js';\nimport { DSTooltipArrow } from './DSTooltipArrow.js';\nimport type { DSTooltipT } from './index.js';\nimport { tooltipV2Props } from './propTypes.js';\nimport { setMultipleRefs } from './utils/setMultipleRefs.js';\n\nconst DSTooltipV2 = ({\n  containerProps = {},\n  innerRef,\n  placement = tooltipPositions.BOTTOM,\n  title = '',\n  delayClose = DEFAULT_DELAY_CLOSE,\n  delayOpen = DEFAULT_DELAY_OPEN,\n  triggerComponent = null,\n  className = '',\n  getIsOpen = () => null,\n  onOpen = () => null,\n  tooltipType = TooltipType.TOOLTIP,\n  showArrow = true,\n  offset = [0, 14],\n  zIndex,\n  extraModifiers = {},\n}: DSTooltipT): React.ReactElement => {\n  useDeprecateComponent({ componentName: 'ds-tooltip-v2', version: 'TBD Date: 2023 Q3' });\n\n  const [showTooltip, setShowTooltip] = useState<boolean>(false);\n  const [isAnimating, setIsAnimating] = useState<boolean>(false);\n  const [referenceElement, setReferenceElement] = useState<HTMLElement | null>(triggerComponent);\n  const [popperElement, setPopperElement] = useState<HTMLDivElement | null>(null);\n  const [arrowElement, setArrowElement] = useState<HTMLDivElement | null>(null);\n  const timerOpen = useRef(null);\n  const timerClosed = useRef(null);\n\n  const { styles, attributes } = usePopper(referenceElement, popperElement, {\n    placement,\n    modifiers: [\n      { name: 'hide', enabled: true },\n      {\n        name: 'offset',\n        enabled: true,\n        options: {\n          offset: tooltipType === TooltipType.TOOLBAR ? [0, 0] : offset,\n        },\n      },\n      { name: 'arrow', options: { element: arrowElement } },\n      { ...extraModifiers },\n    ],\n  });\n\n  const handleShowTooltipOn = useCallback(() => {\n    timerOpen.current = setTimeout(() => {\n      setShowTooltip(true);\n      setIsAnimating(true);\n      getIsOpen(true);\n      onOpen();\n    }, delayOpen);\n  }, [delayOpen, getIsOpen, onOpen]);\n\n  const handleShowTooltipOff = useCallback(() => {\n    timerClosed.current = setTimeout(() => {\n      setShowTooltip(false);\n      setIsAnimating(true);\n      getIsOpen(false);\n    }, delayClose);\n  }, [delayClose, getIsOpen]);\n\n  const handleKeyDown = useCallback((e) => {\n    if (e.key === 'Escape') {\n      e.target.blur();\n    }\n  }, []);\n\n  const checkAnimationStatus = useCallback(() => {\n    if (!showTooltip) {\n      setIsAnimating(false);\n    }\n  }, [showTooltip]);\n\n  useEffect(\n    () => () => {\n      clearTimeout(timerClosed.current);\n      clearTimeout(timerOpen.current);\n    },\n    [],\n  );\n\n  const theme = useContext(ThemeContext);\n\n  return (\n    <>\n      <StyledTriggerComponentContainer\n        ref={setReferenceElement}\n        onMouseEnter={handleShowTooltipOn}\n        onMouseLeave={handleShowTooltipOff}\n        onFocus={handleShowTooltipOn}\n        onBlur={handleShowTooltipOff}\n        onKeyDown={handleKeyDown}\n      >\n        {triggerComponent}\n      </StyledTriggerComponentContainer>\n      {isAnimating || showTooltip ? (\n        <DSPortal>\n          <StyledTooltipContainer\n            className={className}\n            showTooltip={showTooltip}\n            tooltipType={tooltipType}\n            data-testid=\"ds-tooltip-container\"\n            ref={(ref) => setMultipleRefs(setPopperElement, innerRef)(ref)}\n            style={{ ...styles.popper, zIndex: zIndex ?? theme.zIndex.tooltip }}\n            {...containerProps}\n            {...attributes.popper}\n          >\n            <StyledAnimatedTooltip\n              showTooltip={showTooltip}\n              data-testid=\"ds-tooltip\"\n              onAnimationEnd={checkAnimationStatus}\n            >\n              <StyledTooltipText>{title}</StyledTooltipText>\n              {tooltipType === TooltipType.TOOLTIP && showArrow ? (\n                <DSTooltipArrow\n                  arrowElementRef={setArrowElement}\n                  style={styles.arrow}\n                  placement={attributes.popper ? attributes.popper['data-popper-placement'] : 'bottom'}\n                />\n              ) : null}\n            </StyledAnimatedTooltip>\n          </StyledTooltipContainer>\n        </DSPortal>\n      ) : null}\n    </>\n  );\n};\n\nDSTooltipV2.propTypes = tooltipV2Props;\nDSTooltipV2.displayName = 'DSTooltipV2';\nconst TooltipV2WithSchema = describe(DSTooltipV2);\nTooltipV2WithSchema.propTypes = tooltipV2Props;\n\nexport { DSTooltipV2, TooltipV2WithSchema };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/v2/DSTooltipArrow.js

@@ -0,0 +1,63 @@
+"use strict";
+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 DSTooltipArrow_exports = {};
+__export(DSTooltipArrow_exports, {
+  DSTooltipArrow: () => DSTooltipArrow
+});
+module.exports = __toCommonJS(DSTooltipArrow_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_styles = require("./styles.js");
+const DSTooltipArrow = ({ placement, style, arrowElementRef }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+  import_styles.StyledTooltipArrow,
+  {
+    "data-placement": placement,
+    style,
+    ref: arrowElementRef,
+    "data-testid": "ds-tooltip-arrow",
+    children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("svg", { viewBox: "0 0 30 30", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "path",
+        {
+          className: "stroke",
+          d: "M23.7,27.1L17,19.9C16.5,19.3,15.8,19,15,19s-1.6,0.3-2.1,0.9l-6.6,7.2C5.3,28.1,3.4,29,2,29h26\n        C26.7,29,24.6,28.1,23.7,27.1z"
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "path",
+        {
+          className: "fill",
+          d: "M23,27.8c1.1,1.2,3.4,2.2,5,2.2h2H0h2c1.7,0,3.9-1,5-2.2l6.6-7.2c0.7-0.8,2-0.8,2.7,0L23,27.8L23,27.8z"
+        }
+      )
+    ] })
+  },
+  "popper-arrow"
+);
+//# sourceMappingURL=DSTooltipArrow.js.map

package/dist/cjs/v2/DSTooltipArrow.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/v2/DSTooltipArrow.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable eslint-comments/no-unlimited-disable */\n/* eslint-disable */\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nimport React from 'react';\nimport type { DSTooltipArrowT } from './index.d';\nimport { StyledTooltipArrow } from './styles.js';\n\nconst DSTooltipArrow = ({ placement, style, arrowElementRef }: DSTooltipArrowT): React.ReactElement => (\n  <StyledTooltipArrow\n    key=\"popper-arrow\"\n    data-placement={placement}\n    style={style}\n    ref={arrowElementRef}\n    data-testid=\"ds-tooltip-arrow\"\n  >\n    <svg viewBox=\"0 0 30 30\">\n      <path\n        className=\"stroke\"\n        d=\"M23.7,27.1L17,19.9C16.5,19.3,15.8,19,15,19s-1.6,0.3-2.1,0.9l-6.6,7.2C5.3,28.1,3.4,29,2,29h26\n        C26.7,29,24.6,28.1,23.7,27.1z\"\n      />\n      <path\n        className=\"fill\"\n        d=\"M23,27.8c1.1,1.2,3.4,2.2,5,2.2h2H0h2c1.7,0,3.9-1,5-2.2l6.6-7.2c0.7-0.8,2-0.8,2.7,0L23,27.8L23,27.8z\"\n      />\n    </svg>\n  </StyledTooltipArrow>\n);\n\nexport { DSTooltipArrow };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADgBnB;AAVJ,oBAAmC;AAEnC,MAAM,iBAAiB,CAAC,EAAE,WAAW,OAAO,gBAAgB,MAC1D;AAAA,EAAC;AAAA;AAAA,IAEC,kBAAgB;AAAA,IAChB;AAAA,IACA,KAAK;AAAA,IACL,eAAY;AAAA,IAEZ,uDAAC,SAAI,SAAQ,aACX;AAAA;AAAA,QAAC;AAAA;AAAA,UACC,WAAU;AAAA,UACV,GAAE;AAAA;AAAA,MAEJ;AAAA,MACA;AAAA,QAAC;AAAA;AAAA,UACC,WAAU;AAAA,UACV,GAAE;AAAA;AAAA,MACJ;AAAA,OACF;AAAA;AAAA,EAhBI;AAiBN;",
+  "names": []
+}

package/dist/cjs/v2/TooltipType.js

@@ -0,0 +1,39 @@
+"use strict";
+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 TooltipType_exports = {};
+__export(TooltipType_exports, {
+  TooltipType: () => TooltipType
+});
+module.exports = __toCommonJS(TooltipType_exports);
+var React = __toESM(require("react"));
+const TooltipType = {
+  TOOLTIP: "tooltip",
+  TOOLBAR: "toolbar"
+};
+//# sourceMappingURL=TooltipType.js.map

package/dist/cjs/v2/TooltipType.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/v2/TooltipType.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable eslint-comments/no-unlimited-disable */\n/* eslint-disable */\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nconst TooltipType = {\n  TOOLTIP: 'tooltip' as const,\n  TOOLBAR: 'toolbar' as const,\n};\n\nexport { TooltipType };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADIvB,MAAM,cAAc;AAAA,EAClB,SAAS;AAAA,EACT,SAAS;AACX;",
+  "names": []
+}

package/dist/cjs/v2/index.d.js

@@ -0,0 +1,28 @@
+"use strict";
+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 __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 index_d_exports = {};
+module.exports = __toCommonJS(index_d_exports);
+var React = __toESM(require("react"));
+//# sourceMappingURL=index.d.js.map

package/dist/cjs/v2/index.d.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/v2/index.d.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable eslint-comments/no-unlimited-disable */\n/* eslint-disable */\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nimport type React from 'react';\n\ntype TooltipIntercationsT = 'hover' | 'click';\n\ntype TooltipTypesT = 'tooltip' | 'toolbar';\n\ntype TooltipPlacementsT =\n  | 'top'\n  | 'bottom'\n  | 'right'\n  | 'left'\n  | 'top-start'\n  | 'top-end'\n  | 'bottom-start'\n  | 'bottom-end'\n  | 'right-start'\n  | 'right-end'\n  | 'left-start'\n  | 'left-end';\n\ninterface DSTooltipArrowT {\n  placement: string;\n  style: React.CSSProperties;\n  arrowElementRef: React.Dispatch<React.SetStateAction<HTMLDivElement>>;\n}\n\ninterface DSTooltipT {\n  containerProps: Object;\n  innerRef: (ref: HTMLElement) => void;\n  placement: TooltipPlacementsT;\n  title: string | React.ReactElement;\n  delayClose: number;\n  delayOpen: number;\n  interactionType: TooltipIntercationsT;\n  triggerComponent: HTMLElement;\n  className: string;\n  getIsOpen: (status: boolean) => void;\n  onOpen: () => void | null;\n  tooltipType: 'tooltip' | 'toolbar';\n  showArrow: boolean;\n  zIndex: number;\n  offset?: [number | null | undefined, number | null | undefined];\n  extraModifiers: Record<string, unknown>;\n}\n\ninterface TooltipContainerT {\n  className: string;\n  showTooltip: boolean;\n  style: React.CSSProperties;\n  tooltipType: TooltipTypesT;\n}\n\ninterface TooltipAnimationT {\n  showTooltip: boolean;\n}\n\nexport type { DSTooltipT, DSTooltipArrowT, TooltipContainerT, TooltipAnimationT };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;ACAA,YAAuB;",
+  "names": []
+}