@capillarytech/blaze-ui 5.23.3-beta.1 → 5.23.3-beta.10

package/CapLanguageProvider/index.js

@@ -1,51 +1,31 @@
-import { ConfigProvider } from 'antd-v5';
-import enUS from 'antd-v5/locale/en_US';
-import isEmpty from 'lodash/isEmpty';
-import moment from 'moment';
-import React from 'react';
-import { IntlProvider, addLocaleData } from 'react-intl';
-import { connect } from 'react-redux';
-import { bindActionCreators, compose } from 'redux';
-import { createStructuredSelector } from 'reselect';
-import dayjs from "../../utils/dayjs";
-import CapSpin from "../CapSpin";
-import * as action from "./actions";
-import * as types from "./constants";
-import * as selectors from "./selector";
-import { jsx as _jsx } from "react/jsx-runtime";
-var {
-  makeSelectLanguage,
-  makeSelectSupportedLocalesDetails
-} = selectors;
-
-/**
- * Converts locale string to appropriate formats for different libraries.
- *
- * @param lang - Locale string from user.iso_lang or localStorage (e.g., 'en_US', 'en-US', 'fr-FR')
- * @param supportedLocales - Array of supported locale configurations
- * @returns Object containing formatted locales for antd, react-intl, and locize
- *
- * @remarks
- * - Antd uses underscore format (e.g., 'en_US', 'fr_FR')
- * - React Intl uses 2-letter format (e.g., 'en', 'fr')
- * - Locize uses the mapped locize_locale from supportedLocales
- */
-function getAllLocales(_ref) {
-  var _lang$split, _supportedLocales$fin;
-  var {
-    lang,
-    supportedLocales
-  } = _ref;
-  var antdLocale = lang == null ? void 0 : lang.replace('-', '_');
-  var reactIntlLocale = lang == null || (_lang$split = lang.split('-')) == null || (_lang$split = _lang$split[0]) == null || (_lang$split = _lang$split.split('_')) == null ? void 0 : _lang$split[0];
-  var locale = supportedLocales == null || (_supportedLocales$fin = supportedLocales.find(data => data.locale === lang)) == null ? void 0 : _supportedLocales$fin.locize_locale;
-  return {
-    antdLocale,
-    reactIntlLocale,
-    locale
-  };
+import { jsx } from "react/jsx-runtime";
+import { ConfigProvider } from "antd-v5";
+import isEmpty from "lodash/isEmpty";
+import moment from "moment";
+import React from "react";
+import { addLocaleData, IntlProvider } from "react-intl";
+import { connect } from "react-redux";
+import { compose, bindActionCreators } from "redux";
+import { createStructuredSelector } from "reselect";
+import "../utils/dayjs.js";
+import CapSpin from "../CapSpin/index.js";
+import * as CapLanguageProvider_actions from "./actions.js";
+import { getAntdLocale } from "./antdLocales.js";
+import { REQUEST } from "./constants.js";
+import * as CapLanguageProvider_selector from "./selector.js";
+import enUS from "antd-v5/locale/en_US";
+import dayjs from "dayjs";
+const { makeSelectLanguage, makeSelectSupportedLocalesDetails } = CapLanguageProvider_selector;
+function getAllLocales({ lang, supportedLocales }) {
+  var _a, _b, _c, _d;
+  const antdLocale = lang == null ? void 0 : lang.replace("-", "_");
+  const reactIntlLocale = (_c = (_b = (_a = lang == null ? void 0 : lang.split("-")) == null ? void 0 : _a[0]) == null ? void 0 : _b.split("_")) == null ? void 0 : _c[0];
+  const locale = (_d = supportedLocales == null ? void 0 : supportedLocales.find(
+    (data) => data.locale === lang
+  )) == null ? void 0 : _d.locize_locale;
+  return { antdLocale, reactIntlLocale, locale };
 }
-export class CapLanguageProvider extends React.PureComponent {
+class CapLanguageProvider extends React.PureComponent {
   constructor(props) {
     super(props);
     this.state = {
@@ -56,166 +36,114 @@ export class CapLanguageProvider extends React.PureComponent {
     };
   }
   componentDidUpdate() {
-    var {
-      user,
-      supportedLocalesDetails
-    } = this.props;
-    var supportedLocales = supportedLocalesDetails == null ? void 0 : supportedLocalesDetails.supportedLocales;
+    const { user, supportedLocalesDetails } = this.props;
+    const supportedLocales = supportedLocalesDetails == null ? void 0 : supportedLocalesDetails.supportedLocales;
     if (!isEmpty(user) && !isEmpty(supportedLocales) && !this.state.localeLoaded) {
-      this.setState({
-        localeLoaded: true
-      });
+      this.setState({ localeLoaded: true });
       this.updateLocale();
     }
   }
   checkLoginPage() {
-    return window.location.pathname.indexOf('/login') !== -1;
+    return window.location.pathname.indexOf("/login") !== -1;
   }
   loadDefaultLocale() {
-    import(/* webpackIgnore: true */"antd-v5/locale/en_US").then(module => {
-      if (module != null && module.default) {
-        this.setState({
-          locale: module.default
-        });
-      } else {
-        console.error('Failed to load default antd locale (en_US). Using static import fallback.');
-        // Fallback to the statically imported enUS
-        this.setState({
-          locale: enUS
-        });
-      }
-    }).catch(error => {
-      console.error('Failed to load default antd locale (en_US):', error);
-      // Fallback to the statically imported enUS
-      this.setState({
-        locale: enUS
-      });
-    });
+    this.setState({ locale: enUS });
   }
   componentDidMount() {
-    var _this$props$actions;
-    (_this$props$actions = this.props.actions) == null || _this$props$actions.getSupportedLocales({
+    var _a;
+    (_a = this.props.actions) == null ? void 0 : _a.getSupportedLocales({
       supportedLocalesApi: this.props.supportedLocalesApi,
       isSkip: this.checkLoginPage()
     });
   }
   updateLocale() {
-    var _this$props$actions2;
-    var supportedLocalesDetails = this.props.supportedLocalesDetails;
-    var {
-      supportedLocales = []
-    } = supportedLocalesDetails || {};
-    /**
-     * Admin user locale's first locale. Otherwise if org_locale exists -> first org_locale else default_cluster_locale or (en_US);
-     */
-    var userLocale = localStorage.getItem('locale');
-    /**
-     * Initialize with default values.
-     */
-    var locale = 'en-US';
-    var antdLocale = 'en_US';
-    var _reactIntlLocale = 'en';
-    var userDataStr = localStorage.getItem('user');
-    var userData = !isEmpty(userDataStr) ? JSON.parse(userDataStr) : {};
+    var _a;
+    const supportedLocalesDetails = this.props.supportedLocalesDetails;
+    const { supportedLocales = [] } = supportedLocalesDetails || {};
+    const userLocale = localStorage.getItem("locale");
+    let locale = "en-US";
+    let antdLocale = "en_US";
+    let _reactIntlLocale = "en";
+    const userDataStr = localStorage.getItem("user");
+    const userData = !isEmpty(userDataStr) ? JSON.parse(userDataStr) : {};
     if (!isEmpty(userData == null ? void 0 : userData.iso_lang) && !isEmpty(supportedLocales)) {
-      var {
+      const {
         locale: newLocale,
         antdLocale: newAntdLocale,
         reactIntlLocale: newReactIntlLocale
-      } = getAllLocales({
-        lang: userData.iso_lang,
-        supportedLocales
-      });
+      } = getAllLocales({ lang: userData.iso_lang, supportedLocales });
       locale = newLocale || locale;
       antdLocale = newAntdLocale || antdLocale;
       _reactIntlLocale = newReactIntlLocale || _reactIntlLocale;
     } else if (!isEmpty(userLocale) && !isEmpty(supportedLocales)) {
-      var {
-        locale: _newLocale,
-        antdLocale: _newAntdLocale,
+      const {
+        locale: newLocale,
+        antdLocale: newAntdLocale,
         reactIntlLocale: _newReactIntlLocale
-      } = getAllLocales({
-        lang: userLocale,
-        supportedLocales
-      });
-      locale = _newLocale || locale;
-      antdLocale = _newAntdLocale || antdLocale;
+      } = getAllLocales({ lang: userLocale, supportedLocales });
+      locale = newLocale || locale;
+      antdLocale = newAntdLocale || antdLocale;
       _reactIntlLocale = _newReactIntlLocale || _reactIntlLocale;
     }
-    // eslint-disable-next-line no-console
-    console.log('Using locale', locale);
-    (_this$props$actions2 = this.props.actions) == null || _this$props$actions2.getLocizeMessage({
+    console.log("Using locale", locale);
+    (_a = this.props.actions) == null ? void 0 : _a.getLocizeMessage({
       locale,
       isSkip: this.checkLoginPage(),
       locizeApi: this.props.locizeApi
     });
-
-    //keep both moment and dayjs locale in sync
     moment.locale(locale);
-
-    //@TODO: Load translations for dayjs locale after verifying required locales in product
     dayjs.locale(locale);
-
-    /**In case of any errors, use default as fallback. */
-    import(/* webpackIgnore: true */"antd-v5/locale/" + antdLocale).then(module => {
-      this.setState({
-        locale: module.default
-      });
-    }).catch(() => {
-      console.warn("antd es locale-provider module does not exist for " + antdLocale + ". Using en_US instead");
-      import(/* webpackIgnore: true */"antd-v5/locale/en_US").then(module => {
-        this.setState({
-          locale: module.default
-        });
-      });
-    });
-
-    /**In case of any errors, use default as fallback. */
-    import(/* webpackIgnore: true */"react-intl/locale-data/" + _reactIntlLocale + ".js").then(module => {
+    const antdLocaleObj = getAntdLocale(antdLocale);
+    this.setState({ locale: antdLocaleObj });
+    import(`react-intl/locale-data/${_reactIntlLocale}.js`).then((module) => {
       addLocaleData(module.default);
     }).catch(() => {
-      console.warn("react-intl locale-data does not exist for " + _reactIntlLocale + ". Using en instead");
-      import(/* webpackIgnore: true */"react-intl/locale-data/en.js").then(module => {
+      console.warn(
+        `react-intl locale-data does not exist for ${_reactIntlLocale}. Using en instead`
+      );
+      import("react-intl/locale-data/en.js").then((module) => {
         addLocaleData(module.default);
       });
     });
   }
   render() {
-    var {
+    const {
       language,
       messages,
       supportedLocalesDetails = {},
       spinnerVisible = true,
       className
     } = this.props;
-    var languageState = language;
-    var supportedLocalesDetailsState = supportedLocalesDetails;
-    var translatedMessages = (languageState == null ? void 0 : languageState.messages) || messages;
-    var isLoginPage = this.checkLoginPage();
-    var showSpinner = spinnerVisible && !isLoginPage && ((languageState == null ? void 0 : languageState.localeLoading) === types.REQUEST || (supportedLocalesDetailsState == null ? void 0 : supportedLocalesDetailsState.fetchSupportedLocalesStatus) === types.REQUEST);
-    return /*#__PURE__*/_jsx(ConfigProvider, {
-      locale: this.state.locale,
-      children: /*#__PURE__*/_jsx(IntlProvider, {
-        locale: (languageState == null ? void 0 : languageState.locale) || 'en',
+    const languageState = language;
+    const supportedLocalesDetailsState = supportedLocalesDetails;
+    const translatedMessages = (languageState == null ? void 0 : languageState.messages) || messages;
+    const isLoginPage = this.checkLoginPage();
+    const showSpinner = spinnerVisible && !isLoginPage && ((languageState == null ? void 0 : languageState.localeLoading) === REQUEST || (supportedLocalesDetailsState == null ? void 0 : supportedLocalesDetailsState.fetchSupportedLocalesStatus) === REQUEST);
+    return /* @__PURE__ */ jsx(ConfigProvider, { locale: this.state.locale, children: /* @__PURE__ */ jsx(
+      IntlProvider,
+      {
+        locale: (languageState == null ? void 0 : languageState.locale) || "en",
         messages: translatedMessages,
-        onError: () => {},
-        children: /*#__PURE__*/_jsx(CapSpin, {
-          className: className,
-          spinning: showSpinner,
-          children: React.Children.only(this.props.children)
-        })
-      }, (languageState == null ? void 0 : languageState.locale) || 'en')
-    });
+        onError: () => {
+        },
+        children: /* @__PURE__ */ jsx(CapSpin, { className, spinning: showSpinner, children: React.Children.only(this.props.children) })
+      },
+      (languageState == null ? void 0 : languageState.locale) || "en"
+    ) });
   }
 }
-var mapStateToProps = createStructuredSelector({
+const mapStateToProps = createStructuredSelector({
   language: makeSelectLanguage(),
   supportedLocalesDetails: makeSelectSupportedLocalesDetails()
 });
 function mapDispatchToProps(dispatch) {
   return {
-    actions: bindActionCreators(action, dispatch)
+    actions: bindActionCreators(CapLanguageProvider_actions, dispatch)
   };
 }
-var withConnect = connect(mapStateToProps, mapDispatchToProps);
-export default compose(withConnect)(CapLanguageProvider);
+const withConnect = connect(mapStateToProps, mapDispatchToProps);
+const index = compose(withConnect)(CapLanguageProvider);
+export {
+  CapLanguageProvider,
+  index as default
+};

package/CapLanguageProvider/reducer.js

@@ -1,45 +1,35 @@
-/*
- *
- * LanguageProvider reducer
- *
- */
-import { fromJS } from 'immutable';
-import * as types from "./constants";
-export var initialState = fromJS({
-  locale: types.DEFAULT_LOCALE,
-  localeLoading: types.IDLE,
+import { fromJS } from "immutable";
+import { IDLE, DEFAULT_LOCALE, GET_SUPPORTED_LOCALES_FAILURE, FAILURE, GET_SUPPORTED_LOCALES_SUCCESS, SUCCESS, GET_SUPPORTED_LOCALES_REQUEST, REQUEST, GET_LOCIZE_MESSAGE_SKIP, COMPLETE, GET_LOCIZE_MESSAGE_FAILURE, GET_LOCIZE_MESSAGE_SUCCESS, GET_LOCIZE_MESSAGE_REQUEST, CHANGE_LOCALE } from "./constants.js";
+const initialState = fromJS({
+  locale: DEFAULT_LOCALE,
+  localeLoading: IDLE,
   messages: {},
-  fetchSupportedLocalesStatus: types.IDLE,
+  fetchSupportedLocalesStatus: IDLE,
   supportedLocales: []
 });
-var languageProviderReducer = function languageProviderReducer(state, action) {
-  if (state === void 0) {
-    state = initialState;
-  }
-  if (action === void 0) {
-    action = {
-      type: ''
-    };
-  }
+const languageProviderReducer = (state = initialState, action = { type: "" }) => {
   switch (action.type) {
-    case types.CHANGE_LOCALE:
-      return state.set('locale', action.locale || types.DEFAULT_LOCALE);
-    case types.GET_LOCIZE_MESSAGE_REQUEST:
-      return state.set('localeLoading', types.REQUEST);
-    case types.GET_LOCIZE_MESSAGE_SUCCESS:
-      return state.set('localeLoading', types.COMPLETE).set('messages', fromJS(action.data || {})).set('locale', action.locale || types.DEFAULT_LOCALE);
-    case types.GET_LOCIZE_MESSAGE_FAILURE:
-      return state.set('localeLoading', types.COMPLETE).set('messages', fromJS({}));
-    case types.GET_LOCIZE_MESSAGE_SKIP:
-      return state.set('localeLoading', types.COMPLETE);
-    case types.GET_SUPPORTED_LOCALES_REQUEST:
-      return state.set('fetchSupportedLocalesStatus', types.REQUEST).set('supportedLocales', fromJS([]));
-    case types.GET_SUPPORTED_LOCALES_SUCCESS:
-      return state.set('fetchSupportedLocalesStatus', types.SUCCESS).set('supportedLocales', fromJS(action.data || []));
-    case types.GET_SUPPORTED_LOCALES_FAILURE:
-      return state.set('fetchSupportedLocalesStatus', types.FAILURE).set('supportedLocales', fromJS([]));
+    case CHANGE_LOCALE:
+      return state.set("locale", action.locale || DEFAULT_LOCALE);
+    case GET_LOCIZE_MESSAGE_REQUEST:
+      return state.set("localeLoading", REQUEST);
+    case GET_LOCIZE_MESSAGE_SUCCESS:
+      return state.set("localeLoading", COMPLETE).set("messages", fromJS(action.data || {})).set("locale", action.locale || DEFAULT_LOCALE);
+    case GET_LOCIZE_MESSAGE_FAILURE:
+      return state.set("localeLoading", COMPLETE).set("messages", fromJS({}));
+    case GET_LOCIZE_MESSAGE_SKIP:
+      return state.set("localeLoading", COMPLETE);
+    case GET_SUPPORTED_LOCALES_REQUEST:
+      return state.set("fetchSupportedLocalesStatus", REQUEST).set("supportedLocales", fromJS([]));
+    case GET_SUPPORTED_LOCALES_SUCCESS:
+      return state.set("fetchSupportedLocalesStatus", SUCCESS).set("supportedLocales", fromJS(action.data || []));
+    case GET_SUPPORTED_LOCALES_FAILURE:
+      return state.set("fetchSupportedLocalesStatus", FAILURE).set("supportedLocales", fromJS([]));
     default:
       return state;
   }
 };
-export default languageProviderReducer;
+export {
+  languageProviderReducer as default,
+  initialState
+};

package/CapLanguageProvider/saga.js

@@ -1,56 +1,50 @@
-import { takeLatest, call, put } from 'redux-saga/effects';
-import * as types from "./constants";
-export function getLocizeMessage(_ref) {
-  var {
-    locale,
-    locizeApi
-  } = _ref;
-  return function* () {
-    try {
-      var result = yield call(locizeApi, locale);
-      yield put({
-        type: types.GET_LOCIZE_MESSAGE_SUCCESS,
-        data: result,
-        locale
-      });
-    } catch (error) {
+import { takeLatest, call, put } from "redux-saga/effects";
+import { GET_LOCIZE_MESSAGE_REQUEST, GET_SUPPORTED_LOCALES_REQUEST, GET_SUPPORTED_LOCALES_FAILURE, GET_SUPPORTED_LOCALES_SUCCESS, GET_LOCIZE_MESSAGE_SUCCESS, GET_LOCIZE_MESSAGE_FAILURE } from "./constants.js";
+function* getLocizeMessage({ locale, locizeApi }) {
+  try {
+    const result = yield call(locizeApi, locale);
+    yield put({
+      type: GET_LOCIZE_MESSAGE_SUCCESS,
+      data: result,
+      locale
+    });
+  } catch (error) {
+    yield put({
+      type: GET_LOCIZE_MESSAGE_FAILURE,
+      data: error
+    });
+  }
+}
+function* fetchSupportedLocales({ supportedLocalesApi }) {
+  try {
+    const result = yield call(supportedLocalesApi);
+    if (result instanceof Error || !Array.isArray(result)) {
       yield put({
-        type: types.GET_LOCIZE_MESSAGE_FAILURE,
-        data: error
+        type: GET_SUPPORTED_LOCALES_FAILURE
       });
-    }
-  }();
-}
-export function fetchSupportedLocales(_ref2) {
-  var {
-    supportedLocalesApi
-  } = _ref2;
-  return function* () {
-    try {
-      var result = yield call(supportedLocalesApi);
-      if (result instanceof Error || !Array.isArray(result)) {
-        yield put({
-          type: types.GET_SUPPORTED_LOCALES_FAILURE
-        });
-      } else {
-        yield put({
-          type: types.GET_SUPPORTED_LOCALES_SUCCESS,
-          data: result
-        });
-      }
-    } catch (_error) {
+    } else {
       yield put({
-        type: types.GET_SUPPORTED_LOCALES_FAILURE
+        type: GET_SUPPORTED_LOCALES_SUCCESS,
+        data: result
       });
     }
-  }();
+  } catch (_error) {
+    yield put({
+      type: GET_SUPPORTED_LOCALES_FAILURE
+    });
+  }
 }
-export function* watchForFetchSupportedLocales() {
-  // @ts-expect-error - redux-saga Pattern type compatibility: string action types are valid patterns
-  yield takeLatest(types.GET_SUPPORTED_LOCALES_REQUEST, fetchSupportedLocales);
+function* watchForFetchSupportedLocales() {
+  yield takeLatest(GET_SUPPORTED_LOCALES_REQUEST, fetchSupportedLocales);
 }
-export function* watchGetLocizeMessage() {
-  // @ts-expect-error - redux-saga Pattern type compatibility: string action types are valid patterns
-  yield takeLatest(types.GET_LOCIZE_MESSAGE_REQUEST, getLocizeMessage);
+function* watchGetLocizeMessage() {
+  yield takeLatest(GET_LOCIZE_MESSAGE_REQUEST, getLocizeMessage);
 }
-export default [watchGetLocizeMessage, watchForFetchSupportedLocales];
+const saga = [watchGetLocizeMessage, watchForFetchSupportedLocales];
+export {
+  saga as default,
+  fetchSupportedLocales,
+  getLocizeMessage,
+  watchForFetchSupportedLocales,
+  watchGetLocizeMessage
+};

package/CapLanguageProvider/selector.js

@@ -1,38 +1,19 @@
-import { fromJS } from 'immutable';
-import { createSelector } from 'reselect';
-import { initialState } from "./reducer";
-
-/**
- * Direct selector to the languageToggle state domain
- */
-export var selectLanguage = function selectLanguage(state) {
-  if (state === void 0) {
-    state = fromJS({});
-  }
-  return state.get('language', initialState);
-};
-
-/**
- * Select the language locale
- */
-
-/** Matches SupportedLocale in index.tsx for connect() typing */
-
-export var makeSelectLanguage = () => createSelector(selectLanguage, function (substate) {
-  if (substate === void 0) {
-    substate = fromJS({});
-  }
-  return substate.toJS();
-});
-export var makeSelectSupportedLocalesDetails = () => createSelector(selectLanguage, function (substate) {
-  if (substate === void 0) {
-    substate = fromJS({});
-  }
-  var sub = substate;
-  var supportedLocales = sub.get('supportedLocales');
-  var result = {
-    supportedLocales: supportedLocales && typeof supportedLocales.toJS === 'function' ? supportedLocales.toJS() : supportedLocales,
-    fetchSupportedLocalesStatus: sub.get('fetchSupportedLocalesStatus')
+import { fromJS } from "immutable";
+import { createSelector } from "reselect";
+import { initialState } from "./reducer.js";
+const selectLanguage = (state = fromJS({})) => state.get("language", initialState);
+const makeSelectLanguage = () => createSelector(selectLanguage, (substate = fromJS({})) => substate.toJS());
+const makeSelectSupportedLocalesDetails = () => createSelector(selectLanguage, (substate = fromJS({})) => {
+  const sub = substate;
+  const supportedLocales = sub.get("supportedLocales");
+  const result = {
+    supportedLocales: supportedLocales && typeof supportedLocales.toJS === "function" ? supportedLocales.toJS() : supportedLocales,
+    fetchSupportedLocalesStatus: sub.get("fetchSupportedLocalesStatus")
   };
   return result;
-});
+});
+export {
+  makeSelectLanguage,
+  makeSelectSupportedLocalesDetails,
+  selectLanguage
+};

package/CapLanguageProvider/types.js

@@ -1 +1 @@
-export {};
+

package/CapLevelGraphRenderer/Tooltip.js

@@ -1,19 +1,11 @@
-import { ToolsView } from '@antv/x6';
-import React from 'react';
-import { createRoot } from 'react-dom/client';
-import CapTooltip from "../CapTooltip";
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * Custom tooltip tool for x6 graph edges
- * Extends ToolsView.ToolItem to provide tooltip functionality on edge hover
- *
- * Note: Uses type assertions for @antv/x6 properties as the library's TypeScript
- * definitions may not fully expose all ToolItem properties.
- */
+import { jsx } from "react/jsx-runtime";
+import { ToolsView } from "@antv/x6";
+import { createRoot } from "react-dom/client";
+import CapTooltip from "../CapTooltip/index.js";
 class TooltipTool extends ToolsView.ToolItem {
   constructor(props) {
     super(props);
-    this.onMouseMove = e => {
+    this.onMouseMove = (e) => {
       if (this.timer) {
         window.clearTimeout(this.timer);
       }
@@ -29,40 +21,36 @@ class TooltipTool extends ToolsView.ToolItem {
   }
   render() {
     super.render();
-    this.knob = ToolsView.createElement('div', false);
-    this.knob.style.position = 'absolute';
-    var container = this.container;
+    this.knob = ToolsView.createElement("div", false);
+    this.knob.style.position = "absolute";
+    const container = this.container;
     container.appendChild(this.knob);
     this.updatePosition();
-    document.addEventListener('mousemove', this.onMouseMove);
+    document.addEventListener("mousemove", this.onMouseMove);
     return this;
   }
   toggleTooltip(visible) {
-    var root = createRoot(this.knob);
+    const root = createRoot(this.knob);
     if (visible) {
-      var tooltipText = this.options.tooltip;
-      root.render(/*#__PURE__*/_jsx(CapTooltip, {
-        title: tooltipText,
-        visible: true,
-        children: /*#__PURE__*/_jsx("div", {})
-      }));
+      const tooltipText = this.options.tooltip;
+      root.render(
+        /* @__PURE__ */ jsx(CapTooltip, { title: tooltipText, visible: true, children: /* @__PURE__ */ jsx("div", {}) })
+      );
     }
     this.tooltipVisible = visible;
   }
   updatePosition(e) {
-    var {
-      style
-    } = this.knob;
-    var graph = this.graph;
+    const { style } = this.knob;
+    const graph = this.graph;
     if (e && graph) {
-      var p = graph.clientToGraph(e.clientX, e.clientY);
-      style.display = 'block';
-      style.left = p.x + "px";
-      style.top = p.y + "px";
+      const p = graph.clientToGraph(e.clientX, e.clientY);
+      style.display = "block";
+      style.left = `${p.x}px`;
+      style.top = `${p.y}px`;
     } else {
-      style.display = 'none';
-      style.left = '-1000px';
-      style.top = '-1000px';
+      style.display = "none";
+      style.left = "-1000px";
+      style.top = "-1000px";
     }
   }
   onMouseLeave() {
@@ -71,21 +59,22 @@ class TooltipTool extends ToolsView.ToolItem {
       window.clearTimeout(this.timer);
     }
     window.setTimeout(() => this.toggleTooltip(false), this.delay);
-    document.removeEventListener('mousemove', this.onMouseMove);
+    document.removeEventListener("mousemove", this.onMouseMove);
   }
   delegateEvents() {
-    var cellView = this.cellView;
-    cellView.on('cell:mouseleave', this.onMouseLeave, this);
+    const cellView = this.cellView;
+    cellView.on("cell:mouseleave", this.onMouseLeave, this);
     return super.delegateEvents();
   }
   onRemove() {
-    var cellView = this.cellView;
-    // @ts-expect-error - x6's off method signature may vary
-    cellView.off('cell:mouseleave', this.onMouseLeave, this);
+    const cellView = this.cellView;
+    cellView.off("cell:mouseleave", this.onMouseLeave, this);
   }
 }
 TooltipTool.config({
-  tagName: 'div',
+  tagName: "div",
   isSVGElement: false
 });
-export default TooltipTool;
+export {
+  TooltipTool as default
+};