@bydata/react-supertabs 1.1.0

package/dist/TabContext.js

@@ -0,0 +1,1895 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TabContext = void 0;
+exports.TabProvider = TabProvider;
+exports.getUniqueIdentifier = void 0;
+exports.useTabContext = useTabContext;
+var _react = require("react");
+var _reactRouterDom = require("react-router-dom");
+var _usePrevious = _interopRequireDefault(require("./usePrevious"));
+var _Utils = require("./Utils");
+var _Constants = require("./Constants");
+var _excluded = ["subTabs", "level", "order", "tabId", "unique_identifier", "parent_tab_id", "width", "elementWidth"],
+  _excluded2 = ["tab_info"],
+  _excluded3 = ["subTabs", "level", "order", "tabId", "unique_identifier", "parent_tab_id", "width", "elementWidth"],
+  _excluded4 = ["tab_info"],
+  _excluded5 = ["tab_info"],
+  _excluded6 = ["tab_info"],
+  _excluded7 = ["tab_info"];
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+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 _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 _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 _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 = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return _regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine2(u), _regeneratorDefine2(u, o, "Generator"), _regeneratorDefine2(u, n, function () { return this; }), _regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
+function _regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } _regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { _regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, _regeneratorDefine2(e, r, n, t); }
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; } // hooks
+// utils and constants
+function sortSubTabs(tab) {
+  if (tab.subTabs.length > 0) {
+    tab.subTabs.sort(_Utils.sortByOrder);
+    tab.subTabs.forEach(sortSubTabs); // Recursively sort each subTab's subTabs
+  }
+}
+var getUniqueIdentifier = exports.getUniqueIdentifier = function getUniqueIdentifier(user) {
+  var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var ignoreUniqueID = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var entityIdentifierKey = arguments.length > 3 ? arguments[3] : undefined;
+  var id = user.id;
+  var orgValue = user === null || user === void 0 ? void 0 : user[entityIdentifierKey];
+  var uniqueId = null;
+  if (!ignoreUniqueID) {
+    var storageKey = "".concat(prefix, "unique_identifier");
+    uniqueId = localStorage.getItem(storageKey);
+    if (!uniqueId) {
+      uniqueId = (0, _Utils.getUniqueId)();
+      localStorage.setItem(storageKey, uniqueId);
+    }
+  }
+  return [id, orgValue, uniqueId].filter(Boolean).join('_');
+};
+// to use in SuperTabsAPI.js
+
+var maxOrder = 9;
+var TabContext = exports.TabContext = /*#__PURE__*/(0, _react.createContext)({
+  activeTab: {},
+  activeSubTab: {},
+  lastOpenedUrl: {
+    current: {}
+  },
+  isTabDataLoaded: false,
+  isTabDataLoadFailed: false,
+  tabs: [],
+  currentEntityId: null,
+  getUserDetails: function getUserDetails() {},
+  hasPrivilege: function hasPrivilege(privilege) {},
+  updateCurrentTab: function updateCurrentTab() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      tab = _ref.tab,
+      _ref$ignoreActiveTabU = _ref.ignoreActiveTabUpdate,
+      ignoreActiveTabUpdate = _ref$ignoreActiveTabU === void 0 ? false : _ref$ignoreActiveTabU,
+      parentId = _ref.parentId,
+      _ref$isHomeTab = _ref.isHomeTab,
+      isHomeTab = _ref$isHomeTab === void 0 ? false : _ref$isHomeTab,
+      _ref$isSubTab = _ref.isSubTab,
+      isSubTab = _ref$isSubTab === void 0 ? false : _ref$isSubTab,
+      _ref$sort = _ref.sort,
+      sort = _ref$sort === void 0 ? false : _ref$sort;
+  },
+  openTab: function openTab(_ref2) {
+    var tab = _ref2.tab,
+      _ref2$isHomeTab = _ref2.isHomeTab,
+      isHomeTab = _ref2$isHomeTab === void 0 ? false : _ref2$isHomeTab,
+      _ref2$isSubTab = _ref2.isSubTab,
+      isSubTab = _ref2$isSubTab === void 0 ? false : _ref2$isSubTab;
+  },
+  openSubTab: function openSubTab(_ref3) {
+    var tab = _ref3.tab,
+      parentId = _ref3.parentId;
+  },
+  modifyTab: function modifyTab(_ref4) {
+    var oldTab = _ref4.oldTab,
+      newTab = _ref4.newTab,
+      _ref4$isSubTab = _ref4.isSubTab,
+      isSubTab = _ref4$isSubTab === void 0 ? false : _ref4$isSubTab;
+  },
+  openSuperTabOnRowClick: function openSuperTabOnRowClick(_ref5) {
+    var tab = _ref5.tab,
+      _ref5$isSubTab = _ref5.isSubTab,
+      isSubTab = _ref5$isSubTab === void 0 ? true : _ref5$isSubTab;
+  },
+  closeTab: function closeTab(_ref6) {
+    var tab = _ref6.tab,
+      _ref6$isSubTab = _ref6.isSubTab,
+      isSubTab = _ref6$isSubTab === void 0 ? false : _ref6$isSubTab;
+  },
+  reorderTabs: function reorderTabs(_ref7) {
+    var tab = _ref7.tab,
+      order = _ref7.order;
+  },
+  updateCurrentEntityId: function updateCurrentEntityId(entityId) {},
+  handleTabModeChange: function handleTabModeChange() {},
+  updateActiveTab: function updateActiveTab(tab) {},
+  updateActiveSubTab: function updateActiveSubTab(tab) {},
+  updateTabProperty: function updateTabProperty(_ref8) {
+    var propertyToUpdate = _ref8.propertyToUpdate,
+      newValue = _ref8.newValue,
+      entityIdentifierKey = _ref8.entityIdentifierKey,
+      identifierValue = _ref8.identifierValue;
+  },
+  updateTabs: function updateTabs(tabs) {},
+  hiddenExternalToolbars: {},
+  showExternalToolbar: function showExternalToolbar(id) {},
+  hideExternalToolbar: function hideExternalToolbar(id) {},
+  alertService: {
+    alert: function alert() {},
+    error: function error() {},
+    info: function info() {},
+    success: function success() {},
+    warning: function warning() {}
+  }
+});
+function TabProvider(_ref9) {
+  var children = _ref9.children,
+    SITE_PREFIX = _ref9.SITE_PREFIX,
+    SITE_PAGES = _ref9.SITE_PAGES,
+    _ref9$homeUrl = _ref9.homeUrl,
+    homeUrl = _ref9$homeUrl === void 0 ? '/' : _ref9$homeUrl,
+    _ref9$entityIdentifie = _ref9.entityIdentifierKey,
+    entityIdentifierKey = _ref9$entityIdentifie === void 0 ? 'organization_id' : _ref9$entityIdentifie,
+    _ref9$persistTabsAfte = _ref9.persistTabsAfterLogin,
+    persistTabsAfterLogin = _ref9$persistTabsAfte === void 0 ? false : _ref9$persistTabsAfte,
+    _ref9$preventHomeRedi = _ref9.preventHomeRedirect,
+    preventHomeRedirect = _ref9$preventHomeRedi === void 0 ? false : _ref9$preventHomeRedi,
+    _ref9$getUserDetails = _ref9.getUserDetails,
+    getUserDetails = _ref9$getUserDetails === void 0 ? function () {} : _ref9$getUserDetails,
+    _ref9$hasPrivilege = _ref9.hasPrivilege,
+    hasPrivilege = _ref9$hasPrivilege === void 0 ? function (privilege) {} : _ref9$hasPrivilege,
+    _ref9$handleOpenTab = _ref9.handleOpenTab,
+    handleOpenTab = _ref9$handleOpenTab === void 0 ? /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+      return _regenerator().w(function (_context) {
+        while (1) switch (_context.n) {
+          case 0:
+            return _context.a(2);
+        }
+      }, _callee);
+    })) : _ref9$handleOpenTab,
+    _ref9$handleCloseTab = _ref9.handleCloseTab,
+    handleCloseTab = _ref9$handleCloseTab === void 0 ? /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+      return _regenerator().w(function (_context2) {
+        while (1) switch (_context2.n) {
+          case 0:
+            return _context2.a(2);
+        }
+      }, _callee2);
+    })) : _ref9$handleCloseTab,
+    _ref9$handleReorderTa = _ref9.handleReorderTabs,
+    handleReorderTabs = _ref9$handleReorderTa === void 0 ? /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+      return _regenerator().w(function (_context3) {
+        while (1) switch (_context3.n) {
+          case 0:
+            return _context3.a(2);
+        }
+      }, _callee3);
+    })) : _ref9$handleReorderTa,
+    _ref9$getTabs = _ref9.getTabs,
+    getTabs = _ref9$getTabs === void 0 ? /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4() {
+      return _regenerator().w(function (_context4) {
+        while (1) switch (_context4.n) {
+          case 0:
+            return _context4.a(2);
+        }
+      }, _callee4);
+    })) : _ref9$getTabs,
+    _ref9$retainTabsAfter = _ref9.retainTabsAfterEntityChange,
+    retainTabsAfterEntityChange = _ref9$retainTabsAfter === void 0 ? false : _ref9$retainTabsAfter,
+    _ref9$shouldRedirectT = _ref9.shouldRedirectToSubTab,
+    shouldRedirectToSubTab = _ref9$shouldRedirectT === void 0 ? true : _ref9$shouldRedirectT,
+    _ref9$isMobileView = _ref9.isMobileView,
+    isMobileView = _ref9$isMobileView === void 0 ? false : _ref9$isMobileView,
+    _ref9$isDefaultExpand = _ref9.isDefaultExpanded,
+    isDefaultExpanded = _ref9$isDefaultExpand === void 0 ? false : _ref9$isDefaultExpand,
+    _ref9$alertService = _ref9.alertService,
+    alertService = _ref9$alertService === void 0 ? {} : _ref9$alertService;
+  var history = (0, _reactRouterDom.useHistory)();
+  var location = (0, _reactRouterDom.useLocation)();
+  var homeTabIdRef = (0, _react.useRef)(null);
+  var superTabsWrapperElemRef = (0, _react.useRef)(null);
+  var _useState = (0, _react.useState)(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isTabDataLoaded = _useState2[0],
+    setIsTabDataLoaded = _useState2[1];
+  var _useState3 = (0, _react.useState)(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isTabDataLoadFailed = _useState4[0],
+    setIsTabDataLoadFailed = _useState4[1];
+  var _useState5 = (0, _react.useState)(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    openingUnexpandedSubTab = _useState6[0],
+    setOpeningUnexpandedSubTab = _useState6[1];
+  var _useState7 = (0, _react.useState)(false),
+    _useState8 = _slicedToArray(_useState7, 2),
+    closingUnexpandedSubTab = _useState8[0],
+    setClosingUnexpandedSubTab = _useState8[1];
+  var _useState9 = (0, _react.useState)(null),
+    _useState0 = _slicedToArray(_useState9, 2),
+    subTabChange = _useState0[0],
+    setSubTabChange = _useState0[1];
+  var _useState1 = (0, _react.useState)(function () {
+      var _JSON$parse;
+      return ((_JSON$parse = JSON.parse(sessionStorage.getItem("".concat(SITE_PREFIX, "expandedIds")))) === null || _JSON$parse === void 0 || (_JSON$parse = _JSON$parse.find(function (item) {
+        return item.active;
+      })) === null || _JSON$parse === void 0 ? void 0 : _JSON$parse.id) || null;
+    }),
+    _useState10 = _slicedToArray(_useState1, 2),
+    expandedTabID = _useState10[0],
+    setExpandedTabID = _useState10[1];
+  var expandedTabIDRef = (0, _react.useRef)(expandedTabID);
+  var expandedTabIDTimeoutRef = (0, _react.useRef)(null);
+  var currentOpenTabCallerRef = (0, _react.useRef)(null);
+  var _useState11 = (0, _react.useState)({}),
+    _useState12 = _slicedToArray(_useState11, 2),
+    subTabWrapperWidth = _useState12[0],
+    setSubTabWrapperWidth = _useState12[1];
+  var _useState13 = (0, _react.useState)(function () {
+      var _getUserDetails;
+      return ((_getUserDetails = getUserDetails()) === null || _getUserDetails === void 0 ? void 0 : _getUserDetails[entityIdentifierKey]) || null;
+    }),
+    _useState14 = _slicedToArray(_useState13, 2),
+    currentEntityId = _useState14[0],
+    setCurrentEntityId = _useState14[1];
+  var _useState15 = (0, _react.useState)(null),
+    _useState16 = _slicedToArray(_useState15, 2),
+    maxWidth = _useState16[0],
+    setMaxWidth = _useState16[1];
+  var openingUnexpandedSubTabTimeoutRef = (0, _react.useRef)(null);
+  var closingUnexpandedSubTabTimeoutRef = (0, _react.useRef)(null);
+  var _useState17 = (0, _react.useState)([]),
+    _useState18 = _slicedToArray(_useState17, 2),
+    tabs = _useState18[0],
+    setTabs = _useState18[1];
+  var tabsRef = (0, _react.useRef)(tabs);
+  var _useState19 = (0, _react.useState)({}),
+    _useState20 = _slicedToArray(_useState19, 2),
+    activeTab = _useState20[0],
+    setActiveTab = _useState20[1];
+  var _useState21 = (0, _react.useState)({}),
+    _useState22 = _slicedToArray(_useState21, 2),
+    activeSubTab = _useState22[0],
+    setActiveSubTab = _useState22[1];
+  var activeTabRef = (0, _react.useRef)(null);
+  var activeSubTabRef = (0, _react.useRef)(null);
+  var lastOpenedUrl = (0, _react.useRef)({});
+  var updateCurrentTabRef = (0, _react.useRef)(new AbortController());
+  var _useState23 = (0, _react.useState)({}),
+    _useState24 = _slicedToArray(_useState23, 2),
+    hiddenExternalToolbars = _useState24[0],
+    setHiddenExternalToolbars = _useState24[1]; // {id: true} means this toolbar is hidden
+  var _useState25 = (0, _react.useState)(function () {
+      return JSON.parse(localStorage.getItem(SITE_PREFIX + "tab_mode_preference") || "[]");
+    }),
+    _useState26 = _slicedToArray(_useState25, 2),
+    tabModePreference = _useState26[0],
+    setTabModePreference = _useState26[1];
+  var previousEntityId = (0, _usePrevious["default"])(currentEntityId);
+  var closeTabFailedRequestsRef = (0, _react.useRef)({});
+  (0, _react.useEffect)(function () {
+    localStorage.setItem(SITE_PREFIX + "tab_mode_preference", JSON.stringify(tabModePreference));
+  }, [tabModePreference]);
+  var discardSubTabWrapperWidth = (0, _react.useCallback)(function () {
+    setSubTabWrapperWidth(function (prev) {
+      var updated = _objectSpread({}, prev);
+      delete updated[currentEntityId + '_' + activeTabRef.current.id];
+      return updated;
+    });
+  }, [currentEntityId]);
+  var showExternalToolbar = (0, _react.useCallback)(function (id) {
+    setHiddenExternalToolbars(function (prev) {
+      var updated = _objectSpread({}, prev);
+      delete updated[id];
+      return updated;
+    });
+    discardSubTabWrapperWidth();
+  }, []);
+  var hideExternalToolbar = (0, _react.useCallback)(function (id) {
+    setHiddenExternalToolbars(function (prev) {
+      return _objectSpread(_objectSpread({}, prev), {}, _defineProperty({}, id, true));
+    });
+    discardSubTabWrapperWidth();
+  }, []);
+  var updateCurrentEntityId = (0, _react.useCallback)(function (entityId) {
+    setCurrentEntityId(entityId);
+  }, []);
+  var updateTabs = (0, _react.useCallback)(function (tabs) {
+    if (typeof tabs === 'function') {
+      tabsRef.current = tabs(tabsRef.current);
+    } else {
+      tabsRef.current = tabs;
+    }
+    setTabs(tabsRef.current);
+  }, []);
+  var updateExpandedID = (0, _react.useCallback)(function (val) {
+    setExpandedTabID(val);
+    expandedTabIDRef.current = val;
+    var storedExpandedIds = JSON.parse(sessionStorage.getItem("".concat(SITE_PREFIX, "expandedIds"))) || [];
+    if (val) {
+      var isIDPresent = storedExpandedIds.some(function (_ref12) {
+        var id = _ref12.id;
+        return id === val;
+      });
+      if (!isIDPresent) {
+        storedExpandedIds = storedExpandedIds.map(function (item) {
+          return _objectSpread(_objectSpread({}, item), {}, {
+            active: false
+          });
+        });
+        storedExpandedIds.push({
+          id: val,
+          active: true
+        });
+      } else {
+        storedExpandedIds.map(function (item) {
+          return _objectSpread(_objectSpread({}, item), {}, {
+            active: item.id === val
+          });
+        });
+      }
+    }
+    sessionStorage.setItem("".concat(SITE_PREFIX, "expandedIds"), JSON.stringify(storedExpandedIds));
+  }, [SITE_PREFIX]);
+  var updateSubTabChange = (0, _react.useCallback)(function (val) {
+    clearTimeout(expandedTabIDTimeoutRef.current);
+    setSubTabChange(val);
+    if (val) {
+      expandedTabIDTimeoutRef.current = setTimeout(function () {
+        setSubTabChange(null);
+      }, 1000);
+    }
+  }, []);
+  var updateActiveTab = (0, _react.useCallback)(function (tab) {
+    setActiveTab(tab);
+    activeTabRef.current = tab;
+  }, []);
+  var updateActiveSubTab = (0, _react.useCallback)(function (tab) {
+    setActiveSubTab(tab);
+    activeSubTabRef.current = tab;
+  }, []);
+  var updateMaxWidth = (0, _react.useCallback)(function () {
+    var _data$parentIndex, _superTabsWrapperElem;
+    var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : tabsRef.current;
+    if (data.length === 0) return;
+    var openParentTabsLength = data.length;
+    var parentIndex = data.findIndex(function (elem) {
+      var _activeTabRef$current;
+      return elem.id === ((_activeTabRef$current = activeTabRef.current) === null || _activeTabRef$current === void 0 ? void 0 : _activeTabRef$current.id);
+    });
+    var subTabs = ((_data$parentIndex = data[parentIndex]) === null || _data$parentIndex === void 0 ? void 0 : _data$parentIndex.subTabs) || [];
+    var subTabWithOpenOrderOne = subTabs === null || subTabs === void 0 ? void 0 : subTabs.find(function (t) {
+      return t.open_order === 1;
+    });
+    var openedSubTabsLength = subTabs.filter(function (t) {
+      return t.order !== 0;
+    }).length;
+    var totalTabs = openParentTabsLength + (expandedTabIDRef.current ? openedSubTabsLength : subTabWithOpenOrderOne ? 1 : 0);
+    var containerWidth = ((_superTabsWrapperElem = superTabsWrapperElemRef.current) === null || _superTabsWrapperElem === void 0 ? void 0 : _superTabsWrapperElem.offsetWidth) - (_Constants.HomeTabWidth + _Constants.MainTabGap * openParentTabsLength + openedSubTabsLength * _Constants.MarginLeft + _Constants.StackButtonWidth + _Constants.SubTabWrapperPadding);
+    var maxWidth = Math.ceil(containerWidth / totalTabs * 100) / 100;
+    var totalMinWidth = 0;
+    var numElementsNeedingSpace = 0;
+
+    // Calculate the total width and minimum width of all elements
+    var activeTabWidth = activeTabRef.current ? (0, _Utils.getTextWidth)((0, _Utils.getTitle)(activeTabRef.current), _Constants.fontStyle) + 42 : 0;
+    var tabLengthWithoutActiveTab = totalTabs - 1;
+    maxWidth = maxWidth - (activeTabWidth - maxWidth) / tabLengthWithoutActiveTab;
+    setMaxWidth(maxWidth);
+    var newData = data.map(function (tab) {
+      var _activeTabRef$current2;
+      var title = (0, _Utils.getTitle)(tab);
+      var isActiveTab = tab.id === ((_activeTabRef$current2 = activeTabRef.current) === null || _activeTabRef$current2 === void 0 ? void 0 : _activeTabRef$current2.id);
+      var elementWidth = (0, _Utils.getTextWidth)(title, _Constants.fontStyle) + 42;
+      var minWidth = isActiveTab ? elementWidth : Math.min(elementWidth, maxWidth);
+      totalMinWidth += minWidth - (isActiveTab ? 10 : 0);
+      if (elementWidth > maxWidth) numElementsNeedingSpace++;
+      return _objectSpread(_objectSpread({}, tab), {}, {
+        elementWidth: elementWidth,
+        width: minWidth
+      });
+    });
+    if (expandedTabIDRef.current && parentIndex !== -1) {
+      newData[parentIndex].subTabs = subTabs.map(function (tab) {
+        if (tab.order === 0) {
+          return _objectSpread(_objectSpread({}, tab), {}, {
+            width: 0
+          });
+        }
+        var title = (0, _Utils.getTitle)(tab);
+        var elementWidth = Math.ceil((0, _Utils.calculateWidth)({
+          text: title,
+          hasAvatar: tab.showAvatar,
+          addMargin: false
+        }) * 100) / 100;
+        var minWidth = Math.min(elementWidth, maxWidth);
+        totalMinWidth += minWidth;
+        if (elementWidth > maxWidth) numElementsNeedingSpace++;
+        return _objectSpread(_objectSpread({}, tab), {}, {
+          elementWidth: elementWidth,
+          width: minWidth
+        });
+      });
+    } else if (subTabWithOpenOrderOne && parentIndex !== -1) {
+      newData[parentIndex].subTabs = newData[parentIndex].subTabs.map(function (tab) {
+        if (tab.open_order === 1) {
+          var title = (0, _Utils.getTitle)(tab);
+          var elementWidth = Math.ceil((0, _Utils.calculateWidth)({
+            text: title,
+            hasAvatar: tab.showAvatar,
+            addMargin: false
+          }) * 100) / 100;
+          var minWidth = Math.min(elementWidth, maxWidth);
+          totalMinWidth += minWidth;
+          if (elementWidth > maxWidth) numElementsNeedingSpace++;
+          return _objectSpread(_objectSpread({}, tab), {}, {
+            elementWidth: elementWidth,
+            width: elementWidth
+          });
+        }
+        return _objectSpread(_objectSpread({}, tab), {}, {
+          width: 0
+        });
+      });
+    }
+    var remainingSpace = Math.ceil(containerWidth - totalMinWidth);
+
+    // Identify elements that need extra space
+    // Distribute remaining space among elements that need extra width
+    if (remainingSpace > 0 && numElementsNeedingSpace > 0) {
+      newData = newData.map(function (tab) {
+        var spaceNeeded = tab.elementWidth - tab.width;
+        var spaceAllocated = remainingSpace > spaceNeeded ? spaceNeeded : remainingSpace;
+        remainingSpace -= spaceAllocated;
+        return _objectSpread(_objectSpread({}, tab), {}, {
+          width: tab.width + spaceAllocated
+        });
+      });
+      if (remainingSpace > 0) {
+        newData[parentIndex].subTabs = newData[parentIndex].subTabs.map(function (tab) {
+          var spaceNeeded = tab.elementWidth - tab.width;
+          var spaceAllocated = remainingSpace > spaceNeeded ? spaceNeeded : remainingSpace;
+          remainingSpace -= spaceAllocated;
+          return _objectSpread(_objectSpread({}, tab), {}, {
+            width: tab.width + spaceAllocated
+          });
+        });
+      }
+    }
+    updateTabs(newData);
+  }, [updateTabs]);
+  var resetMaxWidth = function resetMaxWidth() {
+    setMaxWidth(null);
+  };
+  var updateTabProperty = (0, _react.useCallback)(function () {
+    var _ref13 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      propertyToUpdate = _ref13.propertyToUpdate,
+      newValue = _ref13.newValue,
+      entityIdentifierKey = _ref13.entityIdentifierKey,
+      identifierValue = _ref13.identifierValue;
+    setTabs(function (tabs) {
+      var updatedTabs = tabs.map(function (tab) {
+        if (tab[entityIdentifierKey] === identifierValue) {
+          return _objectSpread(_objectSpread({}, tab), {}, _defineProperty({}, propertyToUpdate, newValue));
+        }
+        return tab;
+      });
+      tabsRef.current = updatedTabs;
+      return updatedTabs;
+    });
+  }, []);
+  var handleTabModeChange = function handleTabModeChange() {
+    var _activeSubTabRef$curr, _activeTabRef$current3;
+    var tabId = ((_activeSubTabRef$curr = activeSubTabRef.current) === null || _activeSubTabRef$curr === void 0 ? void 0 : _activeSubTabRef$curr.tabId) || ((_activeTabRef$current3 = activeTabRef.current) === null || _activeTabRef$current3 === void 0 ? void 0 : _activeTabRef$current3.tabId);
+    var searchParams = new URLSearchParams(location.search);
+    var isEditMode = searchParams.get("edit") === "true";
+    var updatedTabModePreference = _toConsumableArray(tabModePreference);
+    if (isEditMode) {
+      searchParams["delete"]("edit");
+      updatedTabModePreference = updatedTabModePreference.filter(function (id) {
+        return id !== tabId;
+      });
+    } else {
+      searchParams.set("edit", "true");
+      if (!updatedTabModePreference.includes(tabId)) {
+        updatedTabModePreference = [].concat(_toConsumableArray(updatedTabModePreference), [tabId]);
+      }
+    }
+    setTabModePreference(updatedTabModePreference);
+    history.replace({
+      pathname: location.pathname,
+      search: "?".concat(searchParams.toString())
+    });
+  };
+  var openSuperTabOnRowClick = function openSuperTabOnRowClick() {
+    var _ref14 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      tab = _ref14.tab,
+      _ref14$isSubTab = _ref14.isSubTab,
+      isSubTab = _ref14$isSubTab === void 0 ? true : _ref14$isSubTab;
+    if (tab.isExternal) {
+      window.open(tab.url, '_blank'); // open link in new tab if it is external
+      return;
+    }
+    var isTabOpen = !isSubTab && tabsRef.current.some(function (t) {
+      return t.url === tab.url;
+    });
+    history.push(tab.url);
+    // if (!isSubTab && tab.skipAPICall) return;
+    isSubTab ? openSubTab({
+      tab: tab
+    }) : !isTabOpen ? openTab({
+      tab: tab
+    }) : updateCurrentTab({
+      tab: tab
+    });
+  };
+  var openTab = (0, _react.useCallback)(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5() {
+    var _ref16,
+      tab,
+      _ref16$isHomeTab,
+      isHomeTab,
+      _ref16$isSubTab,
+      isSubTab,
+      _ref16$keepInactive,
+      keepInactive,
+      _payload$tab_info,
+      isEditMode,
+      unique_identifier,
+      activeTabId,
+      subTabs,
+      level,
+      order,
+      tabId,
+      tabUniqueId,
+      parent_tab_id,
+      width,
+      elementWidth,
+      filteredTab,
+      payload,
+      storedExpandedIds,
+      isExpanded,
+      response,
+      _tabId,
+      newTab,
+      _args5 = arguments,
+      _t;
+    return _regenerator().w(function (_context5) {
+      while (1) switch (_context5.p = _context5.n) {
+        case 0:
+          _ref16 = _args5.length > 0 && _args5[0] !== undefined ? _args5[0] : {}, tab = _ref16.tab, _ref16$isHomeTab = _ref16.isHomeTab, isHomeTab = _ref16$isHomeTab === void 0 ? false : _ref16$isHomeTab, _ref16$isSubTab = _ref16.isSubTab, isSubTab = _ref16$isSubTab === void 0 ? false : _ref16$isSubTab, _ref16$keepInactive = _ref16.keepInactive, keepInactive = _ref16$keepInactive === void 0 ? false : _ref16$keepInactive;
+          _context5.p = 1;
+          if (!isSubTab) {
+            updateActiveTab(tab);
+            lastOpenedUrl.current[currentEntityId + '_' + tab.id] = tab;
+          }
+          if (!(!isHomeTab && (isSubTab ? !activeTabRef.current.tabId : !homeTabIdRef.current))) {
+            _context5.n = 2;
+            break;
+          }
+          console.log('Parent id not found', tab, activeTabRef.current.tabId);
+          return _context5.a(2);
+        case 2:
+          isEditMode = tab.url.includes('?edit=true');
+          unique_identifier = getUniqueIdentifier(getUserDetails(), SITE_PREFIX, persistTabsAfterLogin, entityIdentifierKey);
+          activeTabId = activeTabRef.current.id;
+          subTabs = tab.subTabs, level = tab.level, order = tab.order, tabId = tab.tabId, tabUniqueId = tab.unique_identifier, parent_tab_id = tab.parent_tab_id, width = tab.width, elementWidth = tab.elementWidth, filteredTab = _objectWithoutProperties(tab, _excluded);
+          payload = {
+            unique_identifier: unique_identifier,
+            created_by: unique_identifier.split('_')[0],
+            tab_info: _objectSpread(_objectSpread({}, filteredTab), isSubTab && {
+              parent_id: activeTabId
+            })
+          };
+          if (isEditMode) {
+            payload.tab_info.url = tab.url.replace('?edit=true', '');
+          }
+          if (!isHomeTab) {
+            payload.parent_tab_id = isSubTab ? activeTabRef.current.tabId : homeTabIdRef.current;
+          }
+          if (closeTabFailedRequestsRef.current[filteredTab.id]) {
+            payload.tab_id = closeTabFailedRequestsRef.current[filteredTab.id].tabId;
+            delete closeTabFailedRequestsRef.current[filteredTab.id];
+          }
+          if (!isSubTab) {
+            storedExpandedIds = JSON.parse(sessionStorage.getItem("".concat(SITE_PREFIX, "expandedIds"))) || [];
+            isExpanded = storedExpandedIds.some(function (_ref17) {
+              var id = _ref17.id;
+              return id === tab.id;
+            });
+            if (isExpanded) {
+              updateExpandedID(tab.id);
+              requestAnimationFrame(function () {
+                var _superTabsWrapperElem2;
+                (_superTabsWrapperElem2 = superTabsWrapperElemRef.current) === null || _superTabsWrapperElem2 === void 0 || (_superTabsWrapperElem2 = _superTabsWrapperElem2.classList) === null || _superTabsWrapperElem2 === void 0 || _superTabsWrapperElem2.add('nested-tabs-visible');
+              });
+            }
+          }
+          (_payload$tab_info = payload.tab_info) === null || _payload$tab_info === void 0 || delete _payload$tab_info.isClientChanged;
+          // return;
+          currentOpenTabCallerRef.current = payload.tab_info;
+          _context5.n = 3;
+          return handleOpenTab(payload);
+        case 3:
+          response = _context5.v;
+          if (!(response.status === 1)) {
+            _context5.n = 6;
+            break;
+          }
+          _tabId = response.tabId;
+          if (isEditMode) {
+            if (!tabModePreference.includes(_tabId)) {
+              setTabModePreference([].concat(_toConsumableArray(tabModePreference), [_tabId]));
+            }
+          }
+          if (!isHomeTab) {
+            _context5.n = 4;
+            break;
+          }
+          homeTabIdRef.current = _tabId;
+          return _context5.a(2, {
+            tab_info: tab,
+            tabId: _tabId,
+            level: 0
+          });
+        case 4:
+          newTab = _objectSpread(_objectSpread({}, tab), {}, {
+            tabId: _tabId
+          });
+          updateTabs(function (prev) {
+            var tabsCopy = structuredClone(prev);
+            if (isSubTab) {
+              var parentIndex = tabsCopy.findIndex(function (t) {
+                return t.id === activeTabRef.current.id;
+              });
+              if (parentIndex !== -1 && tabsCopy[parentIndex].subTabs) {
+                var currentSubTabExists = tabsCopy[parentIndex].subTabs.find(function (t) {
+                  return t.id === tab.id;
+                });
+                if (!currentSubTabExists) {
+                  tabsCopy[parentIndex].subTabs.push(newTab);
+                } else {
+                  tabsCopy[parentIndex].subTabs = tabsCopy[parentIndex].subTabs.map(function (t) {
+                    return t.id === tab.id ? _objectSpread(_objectSpread({}, t), {}, {
+                      tabId: _tabId
+                    }) : t;
+                  });
+                }
+              }
+              if (!keepInactive) {
+                updateActiveSubTab(newTab);
+                lastOpenedUrl.current[currentEntityId + '_' + activeTabRef.current.id] = newTab;
+              }
+            } else {
+              // when calling sight open tab we are setting subTabs array empty
+              var _subTabs = response.children ? response.children.map(function (t, index) {
+                var tab_info = t.tab_info,
+                  rest = _objectWithoutProperties(t, _excluded2);
+                var flattenedSubTab = _objectSpread(_objectSpread(_objectSpread({}, rest), tab_info), {}, {
+                  tabId: rest.id,
+                  open_order: index + 1
+                });
+                return flattenedSubTab;
+              }) : [];
+              tabsCopy = tabsCopy.map(function (t) {
+                return t.id === tab.id ? _objectSpread(_objectSpread({}, t), {}, {
+                  tabId: _tabId,
+                  subTabs: _subTabs.sort(_Utils.sortByOrder)
+                }) : t;
+              });
+              var pathName = window.location.pathname;
+              var isSubTabActive = _subTabs.find(function (t) {
+                return t.url === pathName;
+              });
+              if (isSubTabActive) updateActiveSubTab(isSubTabActive);
+              updateActiveTab(newTab);
+            }
+            return tabsCopy;
+          });
+          isSubTab ? !keepInactive && updateActiveSubTab(newTab) : updateActiveTab(newTab);
+          return _context5.a(2, {
+            tab_info: tab,
+            id: _tabId,
+            level: isSubTab ? 2 : 1,
+            parent_tab_id: isSubTab ? activeTabRef.current.tabId : homeTabIdRef.current
+          });
+        case 5:
+          _context5.n = 8;
+          break;
+        case 6:
+          if (!(response instanceof DOMException && response.name === 'AbortError')) {
+            _context5.n = 7;
+            break;
+          }
+          return _context5.a(2);
+        case 7:
+          if (window.isDebugOn) {
+            alertService === null || alertService === void 0 || alertService.error(response.msg ? response.msg : 'Error in opening tab!');
+          }
+        case 8:
+          _context5.n = 10;
+          break;
+        case 9:
+          _context5.p = 9;
+          _t = _context5.v;
+          if (window.isDebugOn) {
+            alertService === null || alertService === void 0 || alertService.error(_t.message ? _t.message : 'Error in opening tab!');
+          }
+          console.log("openTab - error", _t);
+        case 10:
+          _context5.p = 10;
+          currentOpenTabCallerRef.current = null;
+          return _context5.f(10);
+        case 11:
+          return _context5.a(2);
+      }
+    }, _callee5, null, [[1, 9, 10, 11]]);
+  })), [handleOpenTab, currentEntityId, tabModePreference]);
+  var updateCurrentTab = (0, _react.useCallback)(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6() {
+    var _ref19,
+      tab,
+      _ref19$ignoreActiveTa,
+      ignoreActiveTabUpdate,
+      parentId,
+      _ref19$isHomeTab,
+      isHomeTab,
+      _ref19$isSubTab,
+      isSubTab,
+      _ref19$sort,
+      sort,
+      _activeSubTabRef$curr2,
+      tabId,
+      _tabDetails$subTabs,
+      _activeSubTabRef$curr3,
+      tabDetails,
+      subTabDetails,
+      _activeTabRef$current5,
+      _tabDetails,
+      unique_identifier,
+      activeTabId,
+      subTabs,
+      level,
+      order,
+      tabIdFromTab,
+      tabUniqueId,
+      parent_tab_id,
+      width,
+      elementWidth,
+      filteredTab,
+      payload,
+      _tabsRef$current$find,
+      storedExpandedIds,
+      isExpanded,
+      hasSubTabs,
+      subTabsWrapperElem,
+      response,
+      _args6 = arguments,
+      _t2;
+    return _regenerator().w(function (_context6) {
+      while (1) switch (_context6.p = _context6.n) {
+        case 0:
+          _ref19 = _args6.length > 0 && _args6[0] !== undefined ? _args6[0] : {}, tab = _ref19.tab, _ref19$ignoreActiveTa = _ref19.ignoreActiveTabUpdate, ignoreActiveTabUpdate = _ref19$ignoreActiveTa === void 0 ? false : _ref19$ignoreActiveTa, parentId = _ref19.parentId, _ref19$isHomeTab = _ref19.isHomeTab, isHomeTab = _ref19$isHomeTab === void 0 ? false : _ref19$isHomeTab, _ref19$isSubTab = _ref19.isSubTab, isSubTab = _ref19$isSubTab === void 0 ? false : _ref19$isSubTab, _ref19$sort = _ref19.sort, sort = _ref19$sort === void 0 ? false : _ref19$sort;
+          _context6.p = 1;
+          if (isSubTab) {
+            lastOpenedUrl.current[currentEntityId + '_' + parentId] = tab;
+            updateActiveSubTab(tab);
+            updateTabs(function (prev) {
+              var updatedData = prev.map(function (t) {
+                return t.url === activeTabRef.current.url ? _objectSpread(_objectSpread({}, t), {}, {
+                  subTabs: (0, _Utils.addOrUpdateSubTab)({
+                    array: t.subTabs,
+                    newTab: tab,
+                    maxOrder: maxOrder,
+                    sort: sort
+                  })
+                }) : t;
+              });
+              // console.log('updateCurrentTab - tabsCopy', updatedData.find(t => t.id === parentId).subTabs.map(t => t.firstName + '_' + t.open_order + '_O-' + t.order));
+              return updatedData;
+            });
+            // setLastOpenedSubTabs((prev) => {
+            //     const updated = { ...prev };
+            //     updated[parentId] = isSubTab ? tab : null;
+            //     return updated;
+            // });
+          } else {
+            if (!ignoreActiveTabUpdate) {
+              lastOpenedUrl.current[currentEntityId + '_' + tab.id] = tab;
+              updateActiveTab(tab);
+              if ((_activeSubTabRef$curr2 = activeSubTabRef.current) !== null && _activeSubTabRef$curr2 !== void 0 && _activeSubTabRef$curr2.url && (0, _Utils.isChildPath)(tab.url, activeSubTabRef.current.url)) {
+                updateActiveSubTab({});
+              }
+            }
+            // updateActiveSubTab({});
+            // setLastOpenedSubTabs((prev) => {
+            //     const updated = { ...prev };
+            //     updated[tab.id] = null;
+            //     return updated;
+            // });
+          }
+
+          // if (tab.skipAPICall) return;
+          if (updateCurrentTabRef.current) {
+            updateCurrentTabRef.current.abort();
+            updateCurrentTabRef.current = new AbortController();
+          }
+          tabId = null;
+          if (isHomeTab) {
+            tabId = homeTabIdRef.current;
+          } else if (isSubTab) {
+            tabDetails = tabsRef.current.find(function (item) {
+              var _activeTabRef$current4;
+              return item.tabId == (parentId || ((_activeTabRef$current4 = activeTabRef.current) === null || _activeTabRef$current4 === void 0 ? void 0 : _activeTabRef$current4.id));
+            });
+            subTabDetails = tabDetails === null || tabDetails === void 0 || (_tabDetails$subTabs = tabDetails.subTabs) === null || _tabDetails$subTabs === void 0 ? void 0 : _tabDetails$subTabs.find(function (item) {
+              return item.id == tab.id || item.url && tab.url && item.url.split('?')[0] === tab.url.split('?')[0];
+            });
+            tabId = ((_activeSubTabRef$curr3 = activeSubTabRef.current) === null || _activeSubTabRef$curr3 === void 0 ? void 0 : _activeSubTabRef$curr3.tabId) || (subTabDetails === null || subTabDetails === void 0 ? void 0 : subTabDetails.tabId);
+          } else {
+            _tabDetails = tabsRef.current.find(function (item) {
+              return item.id == tab.id || item.url && tab.url && item.url.split('?')[0] === tab.url.split('?')[0];
+            });
+            tabId = ((_activeTabRef$current5 = activeTabRef.current) === null || _activeTabRef$current5 === void 0 ? void 0 : _activeTabRef$current5.tabId) || (_tabDetails === null || _tabDetails === void 0 ? void 0 : _tabDetails.tabId);
+          }
+          if (tabId) {
+            _context6.n = 2;
+            break;
+          }
+          // if (!isHomeTab && !homeTabIdRef.current && isSubTab ? !activeTabRef.current.tabId : false) {
+          console.log('Tab not found opening a new tab');
+          openTab({
+            tab: tab,
+            isHomeTab: isHomeTab,
+            isSubTab: isSubTab
+          });
+          return _context6.a(2);
+        case 2:
+          unique_identifier = getUniqueIdentifier(getUserDetails(), SITE_PREFIX, persistTabsAfterLogin, entityIdentifierKey);
+          activeTabId = activeTabRef.current.id;
+          subTabs = tab.subTabs, level = tab.level, order = tab.order, tabIdFromTab = tab.tabId, tabUniqueId = tab.unique_identifier, parent_tab_id = tab.parent_tab_id, width = tab.width, elementWidth = tab.elementWidth, filteredTab = _objectWithoutProperties(tab, _excluded3);
+          payload = {
+            unique_identifier: unique_identifier,
+            tab_id: tabId,
+            created_by: unique_identifier.split('_')[0],
+            tab_info: _objectSpread(_objectSpread({}, filteredTab), isSubTab && {
+              parent_id: tab.parent_id || activeTabId
+            })
+          };
+          if (!isHomeTab) {
+            payload.parent_tab_id = parent_tab_id || (isSubTab ? activeTabRef.current.tabId : homeTabIdRef.current);
+          }
+          if (!(!isHomeTab && !payload.parent_tab_id)) {
+            _context6.n = 3;
+            break;
+          }
+          if (window.isDebugOn) {
+            alertService === null || alertService === void 0 || alertService.error('Parent id not found for updating current tab');
+          }
+          console.log('Parent id not found for updating current tab', tab, activeTabRef.current.tabId);
+          return _context6.a(2);
+        case 3:
+          if (!isSubTab) {
+            storedExpandedIds = JSON.parse(sessionStorage.getItem("".concat(SITE_PREFIX, "expandedIds"))) || [];
+            isExpanded = storedExpandedIds.some(function (_ref20) {
+              var id = _ref20.id;
+              return id === tab.id;
+            });
+            hasSubTabs = ((_tabsRef$current$find = tabsRef.current.find(function (t) {
+              return t.id === tab.id;
+            })) === null || _tabsRef$current$find === void 0 || (_tabsRef$current$find = _tabsRef$current$find.subTabs) === null || _tabsRef$current$find === void 0 ? void 0 : _tabsRef$current$find.length) > 0;
+            if (isExpanded) {
+              updateExpandedID(tab.id);
+              requestAnimationFrame(function () {
+                var _superTabsWrapperElem3;
+                (_superTabsWrapperElem3 = superTabsWrapperElemRef.current) === null || _superTabsWrapperElem3 === void 0 || (_superTabsWrapperElem3 = _superTabsWrapperElem3.classList) === null || _superTabsWrapperElem3 === void 0 || _superTabsWrapperElem3.add('nested-tabs-visible');
+              });
+            } else if (hasSubTabs) {
+              requestAnimationFrame(function () {
+                var _superTabsWrapperElem4;
+                (_superTabsWrapperElem4 = superTabsWrapperElemRef.current) === null || _superTabsWrapperElem4 === void 0 || (_superTabsWrapperElem4 = _superTabsWrapperElem4.classList) === null || _superTabsWrapperElem4 === void 0 || _superTabsWrapperElem4.add('nested-tabs-visible');
+              });
+              subTabsWrapperElem = document.querySelectorAll('.sub-tabs-wrapper');
+              subTabsWrapperElem.forEach(function (elem) {
+                elem.style.transition = "width ease-out ".concat(_Constants.transitionDuration, "ms");
+              });
+              setTimeout(function () {
+                subTabsWrapperElem.forEach(function (elem) {
+                  elem.style.removeProperty('transition');
+                });
+              }, _Constants.transitionDuration + 50);
+            }
+          }
+          _context6.n = 4;
+          return handleOpenTab(payload, updateCurrentTabRef.current);
+        case 4:
+          response = _context6.v;
+          if (!(response.status !== 1)) {
+            _context6.n = 6;
+            break;
+          }
+          if (!(response instanceof DOMException && response.name === 'AbortError')) {
+            _context6.n = 5;
+            break;
+          }
+          return _context6.a(2);
+        case 5:
+          if (window.isDebugOn) {
+            alertService === null || alertService === void 0 || alertService.error(response.msg ? response.msg : 'Error in updating current tab!');
+          }
+        case 6:
+          _context6.n = 8;
+          break;
+        case 7:
+          _context6.p = 7;
+          _t2 = _context6.v;
+          if (window.isDebugOn) {
+            alertService === null || alertService === void 0 || alertService.error(_t2.message ? _t2.message : 'Error in updating current tab!');
+          }
+          console.log("updateCurrentTab - error", _t2);
+        case 8:
+          return _context6.a(2);
+      }
+    }, _callee6, null, [[1, 7]]);
+  })), [handleOpenTab, openTab, currentEntityId]);
+  var openSubTab = (0, _react.useCallback)(/*#__PURE__*/function () {
+    var _ref22 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(_ref21) {
+      var _parentTab, _parentTab2, _parentTab3, _parentTab4;
+      var tab, parentId, _ref21$keepInactive, keepInactive, isSubTabOpen, parentTab, tabsCopy, subTabWithOpenOrderOne, _superTabsWrapperElem5;
+      return _regenerator().w(function (_context7) {
+        while (1) switch (_context7.n) {
+          case 0:
+            tab = _ref21.tab, parentId = _ref21.parentId, _ref21$keepInactive = _ref21.keepInactive, keepInactive = _ref21$keepInactive === void 0 ? false : _ref21$keepInactive;
+            isSubTabOpen = false;
+            parentTab = null;
+            tabsCopy = structuredClone(tabsRef.current);
+            parentTab = tabsCopy.find(function (t) {
+              var _activeTabRef$current6;
+              return t.id === ((_activeTabRef$current6 = activeTabRef.current) === null || _activeTabRef$current6 === void 0 ? void 0 : _activeTabRef$current6.id);
+            });
+            subTabWithOpenOrderOne = (_parentTab = parentTab) === null || _parentTab === void 0 || (_parentTab = _parentTab.subTabs) === null || _parentTab === void 0 ? void 0 : _parentTab.find(function (t) {
+              return t.open_order === 1;
+            }); // Check if subTab already exists by URL or ID to prevent duplicates
+            isSubTabOpen = (_parentTab2 = parentTab) === null || _parentTab2 === void 0 || (_parentTab2 = _parentTab2.subTabs) === null || _parentTab2 === void 0 ? void 0 : _parentTab2.find(function (t) {
+              return t.url && tab.url && t.url.split('?')[0] === tab.url.split('?')[0] || t.id === tab.id;
+            });
+            // Ensure sub tabs are expanded if there is only one sub tab
+            if (isDefaultExpanded && ((_parentTab3 = parentTab) === null || _parentTab3 === void 0 || (_parentTab3 = _parentTab3.subTabs) === null || _parentTab3 === void 0 ? void 0 : _parentTab3.length) === 1) {
+              updateExpandedID(parentTab.id);
+              (_superTabsWrapperElem5 = superTabsWrapperElemRef.current) === null || _superTabsWrapperElem5 === void 0 || _superTabsWrapperElem5.classList.add('nested-tabs-visible');
+            }
+            updateTabs(function () {
+              return tabsCopy.map(function (t) {
+                var _activeTabRef$current7;
+                return t.url === ((_activeTabRef$current7 = activeTabRef.current) === null || _activeTabRef$current7 === void 0 ? void 0 : _activeTabRef$current7.url) ? _objectSpread(_objectSpread({}, t), {}, {
+                  subTabs: (0, _Utils.addOrUpdateSubTab)({
+                    array: t.subTabs,
+                    newTab: tab,
+                    maxOrder: maxOrder
+                  })
+                }) : t;
+              });
+            });
+            if (!keepInactive) {
+              lastOpenedUrl.current[currentEntityId + '_' + parentTab.id] = tab;
+              setActiveSubTab(tab);
+              activeSubTabRef.current = tab;
+            }
+            clearTimeout(openingUnexpandedSubTabTimeoutRef.current);
+            setOpeningUnexpandedSubTab(true);
+            openingUnexpandedSubTabTimeoutRef.current = setTimeout(function () {
+              setOpeningUnexpandedSubTab(false);
+            }, 300);
+            updateMaxWidth();
+            updateSubTabChange({
+              parentTabId: activeTabRef.current.id,
+              oldTab: subTabWithOpenOrderOne,
+              newTab: tab
+            });
+            // if (!isSubTabOpen && !tab.skipAPICall) openTab({ tab, parentId, isSubTab: true, keepInactive });
+            if (!isSubTabOpen) openTab({
+              tab: tab,
+              parentId: parentId,
+              isSubTab: true,
+              keepInactive: keepInactive
+            });
+            if (subTabWrapperWidth[currentEntityId + '_' + ((_parentTab4 = parentTab) === null || _parentTab4 === void 0 ? void 0 : _parentTab4.id)]) {
+              setSubTabWrapperWidth(function (prev) {
+                var updated = _objectSpread({}, prev);
+                delete updated[currentEntityId + '_' + parentTab.id];
+                return updated;
+              });
+            }
+          case 1:
+            return _context7.a(2);
+        }
+      }, _callee7);
+    }));
+    return function (_x) {
+      return _ref22.apply(this, arguments);
+    };
+  }(), [updateTabs, updateMaxWidth, updateSubTabChange, openTab, subTabWrapperWidth, currentEntityId]);
+  var modifyTab = (0, _react.useCallback)(function (_ref23) {
+    var oldTab = _ref23.oldTab,
+      newTab = _ref23.newTab,
+      _ref23$isSubTab = _ref23.isSubTab,
+      isSubTab = _ref23$isSubTab === void 0 ? false : _ref23$isSubTab;
+    var tab = _objectSpread(_objectSpread({}, newTab), {}, {
+      tabId: oldTab.tabId || null
+    });
+    updateTabs(function (prev) {
+      var tabsCopy = structuredClone(prev);
+      var parentIndex = tabsCopy.findIndex(function (t) {
+        return t.id === activeTabRef.current.id;
+      });
+      if (isSubTab) {
+        var childIndex = tabsCopy[parentIndex].subTabs.findIndex(function (t) {
+          return t.id === oldTab.id || t.url && newTab.url && t.url.split('?')[0] === newTab.url.split('?')[0];
+        });
+        if (childIndex !== -1) {
+          tabsCopy[parentIndex].subTabs[childIndex] = tab;
+        } else {
+          tabsCopy[parentIndex].subTabs.push(tab);
+        }
+        lastOpenedUrl.current[currentEntityId + '_' + activeTabRef.current.id] = newTab;
+        updateActiveSubTab(newTab);
+      } else {
+        tabsCopy = tabsCopy.map(function (t) {
+          return t.id === oldTab.id ? newTab : t;
+        });
+        updateActiveTab(newTab);
+      }
+      return tabsCopy;
+    });
+    // openTab({ tab, isSubTab });
+    updateCurrentTab({
+      tab: tab,
+      isSubTab: isSubTab,
+      parentId: activeTabRef.current.id
+    });
+  }, [updateCurrentTab, updateActiveSubTab, updateActiveTab, updateTabs, currentEntityId]);
+  var closeTab = (0, _react.useCallback)(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8() {
+    var _ref25,
+      tab,
+      _ref25$isSubTab,
+      isSubTab,
+      response,
+      _activeSubTabRef$curr5,
+      tabId,
+      updatedTabModePreference,
+      _args8 = arguments,
+      _t3;
+    return _regenerator().w(function (_context8) {
+      while (1) switch (_context8.p = _context8.n) {
+        case 0:
+          _ref25 = _args8.length > 0 && _args8[0] !== undefined ? _args8[0] : {}, tab = _ref25.tab, _ref25$isSubTab = _ref25.isSubTab, isSubTab = _ref25$isSubTab === void 0 ? false : _ref25$isSubTab;
+          _context8.p = 1;
+          if (isSubTab) {
+            clearTimeout(closingUnexpandedSubTabTimeoutRef.current);
+            setClosingUnexpandedSubTab(true);
+            closingUnexpandedSubTabTimeoutRef.current = setTimeout(function () {
+              setClosingUnexpandedSubTab(false);
+            }, 300);
+          }
+          updateTabs(function (prev) {
+            var newTabs = structuredClone(prev);
+            if (prev.length === 0) return newTabs;
+            if (isSubTab) {
+              var _newTabs, _newTabs2, _newTabs3, _newTabs4, _newTabs5, _activeSubTabRef$curr4;
+              var parentTabIndex = (_newTabs = newTabs) === null || _newTabs === void 0 ? void 0 : _newTabs.findIndex(function (data) {
+                return data.id === activeTabRef.current.id;
+              });
+              var subTabIndex = (_newTabs2 = newTabs) === null || _newTabs2 === void 0 || (_newTabs2 = _newTabs2[parentTabIndex]) === null || _newTabs2 === void 0 ? void 0 : _newTabs2.subTabs.findIndex(function (data) {
+                return data.id === tab.id;
+              });
+              var tabOrder = tab.order,
+                tabOpenOrder = tab.open_order;
+              var subTabsLength = (_newTabs3 = newTabs) === null || _newTabs3 === void 0 || (_newTabs3 = _newTabs3[parentTabIndex]) === null || _newTabs3 === void 0 ? void 0 : _newTabs3.subTabs.length;
+              newTabs[parentTabIndex].subTabs = (_newTabs4 = newTabs) === null || _newTabs4 === void 0 || (_newTabs4 = _newTabs4[parentTabIndex]) === null || _newTabs4 === void 0 ? void 0 : _newTabs4.subTabs.filter(function (subTab) {
+                return subTab.id !== tab.id;
+              });
+              var _splitSubTabs = (0, _Utils.splitSubTabs)((_newTabs5 = newTabs) === null || _newTabs5 === void 0 || (_newTabs5 = _newTabs5[parentTabIndex]) === null || _newTabs5 === void 0 ? void 0 : _newTabs5.subTabs),
+                itemsWithOrderZero = _splitSubTabs.itemsWithOrderZero;
+              var nextNonZeroOrderObj = subTabsLength > maxOrder && itemsWithOrderZero.length > 0 ? itemsWithOrderZero.reduce(function (prev, curr) {
+                return prev.open_order < curr.open_order ? prev : curr;
+              }) : null;
+              if (tab.id === ((_activeSubTabRef$curr4 = activeSubTabRef.current) === null || _activeSubTabRef$curr4 === void 0 ? void 0 : _activeSubTabRef$curr4.id)) {
+                if (newTabs[parentTabIndex].subTabs.length > 0) {
+                  var _newActiveSubTab$orde, _newActiveSubTab$open;
+                  var nextSubTab = newTabs[parentTabIndex].subTabs[subTabIndex];
+                  var newActiveSubTab = nextSubTab !== null && nextSubTab !== void 0 ? nextSubTab : newTabs[parentTabIndex].subTabs[subTabIndex - 1];
+                  // const newActiveSubTab = nextSubTab ?? newTabs[parentTabIndex].subTabs.find(subTab => subTab.open_order === tab.open_order + 1);
+                  var _tabOrder = (_newActiveSubTab$orde = newActiveSubTab === null || newActiveSubTab === void 0 ? void 0 : newActiveSubTab.order) !== null && _newActiveSubTab$orde !== void 0 ? _newActiveSubTab$orde : 0;
+                  var _tabOpenOrder = (_newActiveSubTab$open = newActiveSubTab === null || newActiveSubTab === void 0 ? void 0 : newActiveSubTab.open_order) !== null && _newActiveSubTab$open !== void 0 ? _newActiveSubTab$open : 0;
+                  newTabs[parentTabIndex].subTabs = newTabs[parentTabIndex].subTabs.map(function (subTab) {
+                    if (subTab.id === newActiveSubTab.id) {
+                      var order = nextSubTab ? subTab.order - 1 : subTab.order;
+                      return _objectSpread(_objectSpread({}, subTab), {}, {
+                        order: order,
+                        open_order: 1
+                      });
+                    }
+                    if (nextNonZeroOrderObj && subTab.id === nextNonZeroOrderObj.id) {
+                      return _objectSpread(_objectSpread({}, subTab), {}, {
+                        order: maxOrder,
+                        open_order: subTab.open_order - 1
+                      });
+                    }
+                    return _objectSpread(_objectSpread({}, subTab), {}, {
+                      order: subTab.order > _tabOrder ? subTab.order - 1 : subTab.order,
+                      open_order: subTab.open_order > _tabOpenOrder ? subTab.open_order - 1 : subTab.open_order
+                    });
+                  });
+                  updateActiveSubTab(newActiveSubTab);
+                  lastOpenedUrl.current[currentEntityId + '_' + activeTabRef.current.id] = newActiveSubTab;
+                  var url = newActiveSubTab.url;
+                  if (tabModePreference.includes(newActiveSubTab.tabId)) {
+                    url += "?edit=true";
+                  }
+                  history.replace(url);
+                } else {
+                  updateActiveSubTab({});
+                  lastOpenedUrl.current[currentEntityId + '_' + activeTabRef.current.id] = null;
+                  var _url = activeTabRef.current.url;
+                  if (tabModePreference.includes(activeTabRef.current.tabId)) {
+                    _url += "?edit=true";
+                  }
+                  history.replace(_url);
+                }
+              } else {
+                newTabs[parentTabIndex].subTabs = newTabs[parentTabIndex].subTabs.map(function (subTab) {
+                  if (tabOrder === 0) {
+                    return _objectSpread(_objectSpread({}, subTab), {}, {
+                      open_order: subTab.open_order > tabOpenOrder ? subTab.open_order - 1 : subTab.open_order
+                    });
+                  }
+                  if (nextNonZeroOrderObj && subTab.id === nextNonZeroOrderObj.id) {
+                    return _objectSpread(_objectSpread({}, subTab), {}, {
+                      order: maxOrder,
+                      open_order: subTab.open_order - 1
+                    });
+                  }
+                  return _objectSpread(_objectSpread({}, subTab), {}, {
+                    order: subTab.order > tabOrder ? subTab.order - 1 : subTab.order,
+                    open_order: subTab.open_order > tabOpenOrder ? subTab.open_order - 1 : subTab.open_order
+                  });
+                });
+              }
+              newTabs[parentTabIndex].subTabs.sort(_Utils.sortByOrder);
+            } else {
+              var _activeTabRef$current8;
+              if (tab.id === ((_activeTabRef$current8 = activeTabRef.current) === null || _activeTabRef$current8 === void 0 ? void 0 : _activeTabRef$current8.id)) {
+                var tabIndex = newTabs.findIndex(function (data) {
+                  return data.id === tab.id;
+                });
+                if (newTabs.length > 1) {
+                  var nextTab = newTabs[tabIndex + 1];
+                  var newActiveTab = nextTab !== null && nextTab !== void 0 ? nextTab : newTabs[tabIndex - 1];
+                  updateActiveTab(newActiveTab);
+                  lastOpenedUrl.current[currentEntityId + '_' + activeTabRef.current.id] = newActiveTab;
+                  history.replace(newActiveTab.url);
+                } else {
+                  lastOpenedUrl.current[currentEntityId + '_' + activeTabRef.current.id] = null;
+                  updateActiveTab({});
+                  history.replace("/");
+                }
+              }
+              newTabs = newTabs.filter(function (t) {
+                return t.id !== tab.id;
+              });
+            }
+            return newTabs;
+          });
+          if (isSubTab) {
+            updateMaxWidth();
+          }
+
+          // if (tab.skipAPICall) return;
+          if (tab.tabId) {
+            _context8.n = 2;
+            break;
+          }
+          console.log('Tab id not found', tab);
+          history.replace("/");
+          return _context8.a(2);
+        case 2:
+          _context8.n = 3;
+          return handleCloseTab(tab.tabId);
+        case 3:
+          response = _context8.v;
+          if (!(response.status === 1)) {
+            _context8.n = 4;
+            break;
+          }
+          console.log('closeTab - response.current_tab_id', response.current_tab_id, activeSubTabRef.current);
+          // if (isSubTab && response.current_tab_id !== activeSubTabRef.current?.tabId ) {
+          if (isSubTab && activeSubTabRef.current) {
+            if (isSubTab && ((_activeSubTabRef$curr5 = activeSubTabRef.current) === null || _activeSubTabRef$curr5 === void 0 ? void 0 : _activeSubTabRef$curr5.open_order) > 2) {
+              updateCurrentTab({
+                tab: activeSubTabRef.current,
+                isSubTab: true,
+                parentId: activeTabRef.current.id
+              });
+            }
+            activeSubTabRef.current.open_order = 1;
+          }
+          tabId = tab.tabId;
+          updatedTabModePreference = _toConsumableArray(tabModePreference);
+          if (updatedTabModePreference.includes(tabId)) {
+            updatedTabModePreference = updatedTabModePreference.filter(function (id) {
+              return id !== tabId;
+            });
+            setTabModePreference(updatedTabModePreference);
+          }
+
+          // console.log('response', response);
+          _context8.n = 6;
+          break;
+        case 4:
+          if (!(response instanceof DOMException && response.name === 'AbortError')) {
+            _context8.n = 5;
+            break;
+          }
+          return _context8.a(2);
+        case 5:
+          if (window.isDebugOn) {
+            alertService === null || alertService === void 0 || alertService.error(response.msg ? response.msg : 'Error in closing tab!');
+          }
+          closeTabFailedRequestsRef.current[tab.id] = tab;
+        case 6:
+          _context8.n = 8;
+          break;
+        case 7:
+          _context8.p = 7;
+          _t3 = _context8.v;
+          if (window.isDebugOn) {
+            alertService === null || alertService === void 0 || alertService.error(_t3.message ? _t3.message : 'Error in closing tab!');
+          }
+          console.log("closeTab - error", _t3);
+          closeTabFailedRequestsRef.current[tab.id] = tab;
+        case 8:
+          return _context8.a(2);
+      }
+    }, _callee8, null, [[1, 7]]);
+  })), [handleCloseTab, updateCurrentTab, currentEntityId, tabModePreference]);
+  var reorderTabs = (0, _react.useCallback)(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9() {
+    var _ref27,
+      tab,
+      order,
+      payload,
+      response,
+      _args9 = arguments,
+      _t4;
+    return _regenerator().w(function (_context9) {
+      while (1) switch (_context9.p = _context9.n) {
+        case 0:
+          _ref27 = _args9.length > 0 && _args9[0] !== undefined ? _args9[0] : {}, tab = _ref27.tab, order = _ref27.order;
+          _context9.p = 1;
+          if (tab.tabId) {
+            _context9.n = 2;
+            break;
+          }
+          // alertService?.error('Tab id not found');
+          console.log('Tab id not found', tab);
+          return _context9.a(2);
+        case 2:
+          payload = {
+            tab_id: tab.tabId.toString(),
+            new_order: order
+          };
+          _context9.n = 3;
+          return handleReorderTabs(payload);
+        case 3:
+          response = _context9.v;
+          if (!(response.status !== 1)) {
+            _context9.n = 5;
+            break;
+          }
+          if (!(response instanceof DOMException && response.name === 'AbortError')) {
+            _context9.n = 4;
+            break;
+          }
+          return _context9.a(2);
+        case 4:
+          if (window.isDebugOn) {
+            alertService === null || alertService === void 0 || alertService.error(response.msg ? response.msg : 'Error in reordering tabs!');
+          }
+        case 5:
+          _context9.n = 7;
+          break;
+        case 6:
+          _context9.p = 6;
+          _t4 = _context9.v;
+          if (window.isDebugOn) {
+            alertService === null || alertService === void 0 || alertService.error(_t4.message ? _t4.message : 'Error in reordering tabs!');
+          }
+          console.log("reorderTabs - error", _t4);
+        case 7:
+          return _context9.a(2);
+      }
+    }, _callee9, null, [[1, 6]]);
+  })), [handleReorderTabs]);
+
+  /*
+  * Closing level 1 tabs whose access is removed on backend and filtering level 2 tabs related to closed level 1 tabs.
+  */
+  var removeTabsWithoutAccess = (0, _react.useCallback)(function (tabs) {
+    var tabsWithAccess = [];
+    var tabIdsWithoutAccess = [];
+    tabs.forEach(function (tab) {
+      var _tab$tab_info;
+      if (tab.level === 1 && !hasPrivilege((_tab$tab_info = tab.tab_info) === null || _tab$tab_info === void 0 ? void 0 : _tab$tab_info.privilege)) {
+        // Here we are closing only level 1 tabs only subtabs will be automatically closed on backend
+        tabIdsWithoutAccess.push(tab.id);
+        closeTab({
+          tab: _objectSpread(_objectSpread({}, tab), {}, {
+            tabId: tab.id
+          }),
+          isSubTab: tab.level === 2
+        });
+      } else {
+        tabsWithAccess.push(tab);
+      }
+    });
+    return tabsWithAccess.filter(function (tab) {
+      return !tabIdsWithoutAccess.includes(tab.parent_tab_id);
+    }); // Here we are filtering out subtabs (level 2) of no access tabs (level 1)
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [closeTab]);
+  /**
+   * Identifies and closes duplicate tabs based on their URLs
+   * 
+   * @param {Array} data - Array of tab objects to check for duplicates
+   * @returns {Array} - Array of tabs with duplicates removed
+   */
+  var findDuplicateEntriesAndCloseTab = (0, _react.useCallback)(/*#__PURE__*/function () {
+    var _ref28 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee0(data) {
+      var urlMap, uniqueTabs, _iterator, _step, _step$value, url, tabsWithSameUrl, i, _t5, _t6, _t7;
+      return _regenerator().w(function (_context0) {
+        while (1) switch (_context0.p = _context0.n) {
+          case 0:
+            _context0.p = 0;
+            // Track URLs we've seen and tabs we'll keep
+            urlMap = new Map();
+            uniqueTabs = []; // First pass - identify duplicates while preserving original order
+            data.forEach(function (element) {
+              if (!element || !element.tab_info) return;
+              var url = element.tab_info.url;
+              if (!url) return;
+              var normalizedUrl = (0, _Utils.normalizeUrl)(url);
+              if (urlMap.has(normalizedUrl)) {
+                // Add to existing entry's list
+                urlMap.get(normalizedUrl).push(element);
+              } else {
+                // Create new entry
+                urlMap.set(normalizedUrl, [element]);
+                uniqueTabs.push(element);
+              }
+            });
+
+            // Second pass - close duplicates sequentially
+            _iterator = _createForOfIteratorHelper(urlMap.entries());
+            _context0.p = 1;
+            _iterator.s();
+          case 2:
+            if ((_step = _iterator.n()).done) {
+              _context0.n = 10;
+              break;
+            }
+            _step$value = _slicedToArray(_step.value, 2), url = _step$value[0], tabsWithSameUrl = _step$value[1];
+            if (!(tabsWithSameUrl.length <= 1)) {
+              _context0.n = 3;
+              break;
+            }
+            return _context0.a(3, 9);
+          case 3:
+            i = 1;
+          case 4:
+            if (!(i < tabsWithSameUrl.length)) {
+              _context0.n = 9;
+              break;
+            }
+            _context0.p = 5;
+            _context0.n = 6;
+            return closeTab({
+              tab: _objectSpread(_objectSpread({}, tabsWithSameUrl[i]), {}, {
+                tabId: tabsWithSameUrl[i].id
+              }),
+              isSubTab: tabsWithSameUrl[i].level === 2
+            });
+          case 6:
+            _context0.n = 8;
+            break;
+          case 7:
+            _context0.p = 7;
+            _t5 = _context0.v;
+            console.error("Error closing duplicate tab:", _t5);
+          case 8:
+            i++;
+            _context0.n = 4;
+            break;
+          case 9:
+            _context0.n = 2;
+            break;
+          case 10:
+            _context0.n = 12;
+            break;
+          case 11:
+            _context0.p = 11;
+            _t6 = _context0.v;
+            _iterator.e(_t6);
+          case 12:
+            _context0.p = 12;
+            _iterator.f();
+            return _context0.f(12);
+          case 13:
+            return _context0.a(2, uniqueTabs);
+          case 14:
+            _context0.p = 14;
+            _t7 = _context0.v;
+            console.error("Error in findDuplicateEntriesAndCloseTab:", _t7);
+            return _context0.a(2, data);
+        }
+      }, _callee0, null, [[5, 7], [1, 11, 12, 13], [0, 14]]);
+    }));
+    return function (_x2) {
+      return _ref28.apply(this, arguments);
+    };
+  }(), [closeTab]);
+  (0, _react.useEffect)(function () {
+    // only run actual logic when currentEntityId changes
+    if (previousEntityId == currentEntityId) {
+      return;
+    }
+    var controller = new AbortController();
+    if (currentEntityId != null && currentEntityId != undefined) {
+      var fetchTabDetails = /*#__PURE__*/function () {
+        var _ref29 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee10() {
+          var href, orgId, payload, response, _response$current_tab, _response$current_tab2, _response$current_tab4, pathName, isHomeTab, tabsOutputWithoutDuplicates, tabsOutput, _activeTab, _activeSubTab, currentActiveTab, _activeTab2, _response$current_tab3, tab_info, rest, flattenedObj, isCurrentTabOpen, openedParentTab, updatedParentTab, flattenedParentObj, parentTab, _activeSubTabRef$curr6, parentTabFromData, _flattenedParentObj, _tab_info, _rest, _flattenedObj, isSubTab, parent, parentTabInfo, parentRest, _flattenedParentObj2, tabsMap, restTabs, id, _tabsMap$id, _activeSubTab$tabId, _activeSubTab2, _activeTab3, tabId, isEditMode, tempTabModePreference, updated, _t8;
+          return _regenerator().w(function (_context10) {
+            while (1) switch (_context10.p = _context10.n) {
+              case 0:
+                _context10.p = 0;
+                href = new URL(window.location.href);
+                orgId = href.searchParams.get('org_id');
+                if (!(orgId && +orgId !== currentEntityId)) {
+                  _context10.n = 1;
+                  break;
+                }
+                return _context10.a(2);
+              case 1:
+                payload = {
+                  unique_identifier: getUniqueIdentifier(getUserDetails(), SITE_PREFIX, persistTabsAfterLogin, entityIdentifierKey)
+                };
+                _context10.n = 2;
+                return getTabs({
+                  payload: payload,
+                  controller: controller
+                });
+              case 2:
+                response = _context10.v;
+                if (!(response.status === 1)) {
+                  _context10.n = 13;
+                  break;
+                }
+                pathName = window.location.pathname;
+                isHomeTab = pathName === homeUrl;
+                _context10.n = 3;
+                return findDuplicateEntriesAndCloseTab(response.tabs);
+              case 3:
+                tabsOutputWithoutDuplicates = _context10.v;
+                tabsOutput = removeTabsWithoutAccess(tabsOutputWithoutDuplicates);
+                _activeTab = null;
+                _activeSubTab = null;
+                currentActiveTab = null;
+                homeTabIdRef.current = tabsOutput.find(function (tab) {
+                  return tab.level === 0;
+                }).id;
+
+                // This needs to be handled with props as optional as should we redirect to subtab on not
+                if (shouldRedirectToSubTab && isHomeTab && response !== null && response !== void 0 && (_response$current_tab = response.current_tab) !== null && _response$current_tab !== void 0 && _response$current_tab.level && ((_response$current_tab2 = response.current_tab) === null || _response$current_tab2 === void 0 ? void 0 : _response$current_tab2.level) !== 0) {
+                  _response$current_tab3 = response.current_tab, tab_info = _response$current_tab3.tab_info, rest = _objectWithoutProperties(_response$current_tab3, _excluded4);
+                  flattenedObj = _objectSpread(_objectSpread(_objectSpread({}, rest), tab_info), {}, {
+                    tabId: rest.id,
+                    subTabs: []
+                  });
+                  _activeTab = flattenedObj;
+                  // lastOpenedUrl.current[activeTab.id] = activeTab.url;
+                  pathName = (_activeTab2 = _activeTab) === null || _activeTab2 === void 0 ? void 0 : _activeTab2.url;
+                  if (_activeTab.level > 1) {
+                    _activeSubTab = _activeTab;
+                    // lastOpenedUrl.current[activeTab.id] = activeSubTab.url;
+                  }
+                  isHomeTab = false;
+                  history.replace(pathName);
+                }
+                isCurrentTabOpen = !isHomeTab && tabsOutput.find(function (tab) {
+                  var _tab$tab_info$url;
+                  return ((_tab$tab_info$url = tab.tab_info.url) === null || _tab$tab_info$url === void 0 || (_tab$tab_info$url = _tab$tab_info$url.split('?')) === null || _tab$tab_info$url === void 0 ? void 0 : _tab$tab_info$url[0]) === pathName;
+                });
+                if (isCurrentTabOpen) {
+                  _context10.n = 11;
+                  break;
+                }
+                openedParentTab = SITE_PAGES.find(function (page) {
+                  return page.url === pathName;
+                });
+                if (!openedParentTab) {
+                  _context10.n = 7;
+                  break;
+                }
+                if (!hasPrivilege(openedParentTab.privilege)) {
+                  _context10.n = 5;
+                  break;
+                }
+                _context10.n = 4;
+                return openTab({
+                  tab: openedParentTab
+                });
+              case 4:
+                updatedParentTab = _context10.v;
+                flattenedParentObj = _objectSpread(_objectSpread(_objectSpread({}, updatedParentTab), updatedParentTab.tab_info), {}, {
+                  tabId: updatedParentTab.id
+                });
+                _activeTab = flattenedParentObj;
+                tabsOutput.push(updatedParentTab);
+                _context10.n = 6;
+                break;
+              case 5:
+                history.push(homeUrl);
+              case 6:
+                _context10.n = 10;
+                break;
+              case 7:
+                if (isHomeTab) {
+                  _context10.n = 10;
+                  break;
+                }
+                parentTab = (0, _Utils.findBestMatchFromPages)([(0, _Utils.getHomeTab)(homeUrl)].concat(_toConsumableArray(SITE_PAGES)), pathName);
+                if (!parentTab) {
+                  _context10.n = 10;
+                  break;
+                }
+                parentTabFromData = tabsOutput.find(function (tab) {
+                  return tab.tab_info.id === parentTab.id;
+                });
+                if (parentTabFromData) {
+                  _context10.n = 9;
+                  break;
+                }
+                _context10.n = 8;
+                return openTab({
+                  tab: parentTab
+                });
+              case 8:
+                parentTabFromData = _context10.v;
+                tabsOutput.push(parentTabFromData);
+              case 9:
+                _flattenedParentObj = parentTabFromData ? _objectSpread(_objectSpread(_objectSpread({}, parentTabFromData), parentTabFromData.tab_info), {}, {
+                  tabId: parentTabFromData.id
+                }) : null;
+                delete _flattenedParentObj.tab_info;
+                _activeTab = _flattenedParentObj !== null && _flattenedParentObj !== void 0 ? _flattenedParentObj : parentTab;
+                _activeSubTab = _objectSpread(_objectSpread({}, parentTab), {}, {
+                  id: "sub_".concat(parentTab.id),
+                  url: pathName,
+                  name: 'Loading...',
+                  title: ''
+                });
+                if ((_activeSubTabRef$curr6 = activeSubTabRef.current) !== null && _activeSubTabRef$curr6 !== void 0 && _activeSubTabRef$curr6.tabId) _activeSubTab.tabId = activeSubTabRef.current.tabId;
+              case 10:
+                _context10.n = 12;
+                break;
+              case 11:
+                _tab_info = isCurrentTabOpen.tab_info, _rest = _objectWithoutProperties(isCurrentTabOpen, _excluded5);
+                _flattenedObj = _objectSpread(_objectSpread(_objectSpread({}, _rest), _tab_info), {}, {
+                  tabId: _rest.id
+                });
+                isSubTab = isCurrentTabOpen.level !== 1;
+                if (isSubTab) {
+                  parent = tabsOutput.find(function (tab) {
+                    return tab.id === _flattenedObj.parent_tab_id;
+                  });
+                  parentTabInfo = parent.tab_info, parentRest = _objectWithoutProperties(parent, _excluded6);
+                  _flattenedParentObj2 = _objectSpread(_objectSpread(_objectSpread({}, parentRest), parentTabInfo), {}, {
+                    tabId: parentRest.id
+                  });
+                  _activeTab = _flattenedParentObj2;
+                  _activeSubTab = _flattenedObj;
+                } else {
+                  _activeTab = _flattenedObj;
+                }
+                currentActiveTab = {
+                  tab: _flattenedObj,
+                  isSubTab: isSubTab,
+                  parentId: _flattenedObj.parent_tab_id
+                };
+              case 12:
+                tabsMap = {};
+                restTabs = [];
+                tabsOutput.sort(function (a, b) {
+                  return a.level - b.level;
+                }).forEach(function (obj) {
+                  var tab_info = obj.tab_info,
+                    rest = _objectWithoutProperties(obj, _excluded7);
+                  var flattenedObj = _objectSpread(_objectSpread(_objectSpread({}, rest), tab_info), {}, {
+                    tabId: rest.id,
+                    subTabs: []
+                  });
+                  tabsMap[flattenedObj.tabId] = flattenedObj;
+                  if (flattenedObj.level !== 0) {
+                    if (flattenedObj.parent_tab_id in tabsMap) {
+                      tabsMap[flattenedObj.parent_tab_id].subTabs.push(flattenedObj);
+                    } else {
+                      tabsMap[flattenedObj.parent_tab_id] = {
+                        subTabs: [flattenedObj]
+                      };
+                    }
+                  }
+                });
+
+                // Collect top-level tabs that have children
+                for (id in tabsMap) {
+                  if (tabsMap[id].level === 0 && tabsMap[id].subTabs.length > 0) {
+                    tabsMap[id].subTabs = (_tabsMap$id = tabsMap[id]) === null || _tabsMap$id === void 0 || (_tabsMap$id = _tabsMap$id.subTabs) === null || _tabsMap$id === void 0 ? void 0 : _tabsMap$id.map(function (tab) {
+                      var _tab$subTabs;
+                      if ((tab === null || tab === void 0 || (_tab$subTabs = tab.subTabs) === null || _tab$subTabs === void 0 ? void 0 : _tab$subTabs.length) > 0) {
+                        var level2Tabs = tab.subTabs.filter(function (subTab) {
+                          return subTab.level === 2;
+                        });
+                        // level2Tabs.sort((a, b) => a.order - b.order); // Sort by the existing order
+                        tab.subTabs = level2Tabs.map(function (subTab, index) {
+                          subTab.open_order = index + 1;
+                          return subTab;
+                        });
+                      }
+                      return tab;
+                    });
+                    sortSubTabs(tabsMap[id]);
+                    restTabs.push.apply(restTabs, _toConsumableArray(tabsMap[id].subTabs));
+                  }
+                }
+                if (!isHomeTab) {
+                  // Update the tab mode preference in localStorage
+                  tabId = (_activeSubTab$tabId = (_activeSubTab2 = _activeSubTab) === null || _activeSubTab2 === void 0 ? void 0 : _activeSubTab2.tabId) !== null && _activeSubTab$tabId !== void 0 ? _activeSubTab$tabId : (_activeTab3 = _activeTab) === null || _activeTab3 === void 0 ? void 0 : _activeTab3.tabId;
+                  if (tabId) {
+                    isEditMode = new URLSearchParams(location.search).get("edit") === "true";
+                    tempTabModePreference = JSON.parse(localStorage.getItem(SITE_PREFIX + "tab_mode_preference") || "[]"); // Here we are using localStorage to avoid re-rendering the component when tabModePreference is updated ( Do not use tabModePreference directly here as it will cause memory leak )
+                    if (isEditMode) {
+                      if (!tempTabModePreference.includes(tabId)) {
+                        setTabModePreference([].concat(_toConsumableArray(tempTabModePreference), [tabId]));
+                      }
+                    } else {
+                      updated = tempTabModePreference.filter(function (id) {
+                        return id !== tabId;
+                      });
+                      if (updated.length !== tempTabModePreference.length) {
+                        setTabModePreference(updated);
+                      }
+                    }
+                  }
+                }
+                updateTabs(restTabs);
+                // if (!activeTab) {
+                //     if (SITE_PAGES.find(page => page.url === formattedPathname)) { // add hasPrivilege
+                //         console.log('activeTab if', activeTab, formattedPathname);
+                //         // check privilege and open tab if found and make sure to replace the tab with latest info
+                //         activeTab = SITE_PAGES.find(page => page.url === formattedPathname);
+                //     }
+                // }
+
+                if (_activeTab) {
+                  setActiveTab(_activeTab);
+                  activeTabRef.current = _activeTab;
+                  lastOpenedUrl.current[currentEntityId + '_' + _activeTab.id] = _activeTab;
+                  // if (isDefaultExpanded) updateExpandedID(activeTab.id);
+                }
+                if (_activeSubTab) {
+                  setActiveSubTab(_activeSubTab);
+                  activeSubTabRef.current = _activeSubTab;
+                  lastOpenedUrl.current[currentEntityId + '_' + _activeTab.id] = _activeSubTab;
+                }
+                if (currentActiveTab && currentActiveTab.tab.url !== ((_response$current_tab4 = response.current_tab) === null || _response$current_tab4 === void 0 || (_response$current_tab4 = _response$current_tab4.tab_info) === null || _response$current_tab4 === void 0 ? void 0 : _response$current_tab4.url)) {
+                  updateCurrentTab(currentActiveTab);
+                }
+                setIsTabDataLoaded(true);
+                _context10.n = 17;
+                break;
+              case 13:
+                if (!(response !== null && response !== void 0 && response.hasNoTabs)) {
+                  _context10.n = 15;
+                  break;
+                }
+                _context10.n = 14;
+                return openTab({
+                  tab: (0, _Utils.getHomeTab)(homeUrl),
+                  isHomeTab: true
+                });
+              case 14:
+                if (retainTabsAfterEntityChange) {
+                  if (tabsRef.current.length > 0) {
+                    tabsRef.current.forEach(/*#__PURE__*/function () {
+                      var _ref30 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee1(retainedTab) {
+                        return _regenerator().w(function (_context1) {
+                          while (1) switch (_context1.n) {
+                            case 0:
+                              _context1.n = 1;
+                              return openTab({
+                                tab: retainedTab,
+                                isHomeTab: false,
+                                isSubTab: false
+                              });
+                            case 1:
+                              return _context1.a(2);
+                          }
+                        }, _callee1);
+                      }));
+                      return function (_x3) {
+                        return _ref30.apply(this, arguments);
+                      };
+                    }());
+                    if (activeTab.url) {
+                      history.push(activeTab.url);
+                    }
+                  }
+                }
+                setIsTabDataLoaded(true);
+                return _context10.a(2);
+              case 15:
+                if (!(response instanceof DOMException && response.name === 'AbortError')) {
+                  _context10.n = 16;
+                  break;
+                }
+                return _context10.a(2);
+              case 16:
+                throw new Error((response === null || response === void 0 ? void 0 : response.msg) || (response === null || response === void 0 ? void 0 : response.message) || 'Error fetching tabs');
+              case 17:
+                _context10.n = 19;
+                break;
+              case 18:
+                _context10.p = 18;
+                _t8 = _context10.v;
+                if (window.isDebugOn) {
+                  alertService === null || alertService === void 0 || alertService.error(_t8.message ? _t8.message : 'Error in fetching tabs!');
+                }
+                console.log("fetchTabDetails - error", _t8);
+                setIsTabDataLoadFailed(true);
+              case 19:
+                _context10.p = 19;
+                tabsRef.current = tabsRef.current.map(function (tab) {
+                  return _objectSpread(_objectSpread({}, tab), {}, {
+                    isClientChanged: false
+                  });
+                });
+                return _context10.f(19);
+              case 20:
+                return _context10.a(2);
+            }
+          }, _callee10, null, [[0, 18, 19, 20]]);
+        }));
+        return function fetchTabDetails() {
+          return _ref29.apply(this, arguments);
+        };
+      }();
+      fetchTabDetails({
+        controller: controller
+      });
+    }
+    return function () {
+      return controller.abort();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [getTabs, openTab, updateCurrentTab, currentEntityId, removeTabsWithoutAccess]);
+  (0, _react.useEffect)(function () {
+    return function () {
+      homeTabIdRef.current = null;
+      //remove all subtabs on client change but retain level 1 tab 
+      if (retainTabsAfterEntityChange) {
+        setTabs(function (prev) {
+          return prev.map(function (tab) {
+            return _objectSpread(_objectSpread({}, tab), {}, {
+              subTabs: []
+            });
+          });
+        });
+        tabsRef.current = tabsRef.current.map(function (tab) {
+          return _objectSpread(_objectSpread({}, tab), {}, {
+            subTabs: [],
+            isClientChanged: true
+          });
+        });
+      }
+    };
+  }, [currentEntityId]);
+  (0, _react.useEffect)(function () {
+    return function () {
+      clearTimeout(expandedTabIDTimeoutRef.current);
+      clearTimeout(closingUnexpandedSubTabTimeoutRef.current);
+      clearTimeout(openingUnexpandedSubTabTimeoutRef.current);
+    };
+  }, []);
+  return /*#__PURE__*/React.createElement(TabContext.Provider, {
+    value: {
+      activeTab: activeTab,
+      activeTabRef: activeTabRef,
+      activeSubTab: activeSubTab,
+      activeSubTabRef: activeSubTabRef,
+      closingUnexpandedSubTab: closingUnexpandedSubTab,
+      setClosingUnexpandedSubTab: setClosingUnexpandedSubTab,
+      closingUnexpandedSubTabTimeoutRef: closingUnexpandedSubTabTimeoutRef,
+      openingUnexpandedSubTab: openingUnexpandedSubTab,
+      setOpeningUnexpandedSubTab: setOpeningUnexpandedSubTab,
+      openingUnexpandedSubTabTimeoutRef: openingUnexpandedSubTabTimeoutRef,
+      tabsRef: tabsRef,
+      currentOpenTabCallerRef: currentOpenTabCallerRef,
+      isTabDataLoaded: isTabDataLoaded,
+      isTabDataLoadFailed: isTabDataLoadFailed,
+      lastOpenedUrl: lastOpenedUrl,
+      SITE_PAGES: SITE_PAGES,
+      SITE_PREFIX: SITE_PREFIX,
+      tabs: tabs,
+      currentEntityId: currentEntityId,
+      superTabsWrapperElemRef: superTabsWrapperElemRef,
+      maxWidth: maxWidth,
+      subTabChange: subTabChange,
+      expandedTabID: expandedTabID,
+      updateExpandedID: updateExpandedID,
+      subTabWrapperWidth: subTabWrapperWidth,
+      setSubTabWrapperWidth: setSubTabWrapperWidth,
+      expandedTabIDRef: expandedTabIDRef,
+      updateMaxWidth: updateMaxWidth,
+      setSubTabChange: setSubTabChange,
+      updateSubTabChange: updateSubTabChange,
+      resetMaxWidth: resetMaxWidth,
+      updateCurrentTab: updateCurrentTab,
+      closeTab: closeTab,
+      reorderTabs: reorderTabs,
+      openTab: openTab,
+      openSubTab: openSubTab,
+      modifyTab: modifyTab,
+      openSuperTabOnRowClick: openSuperTabOnRowClick,
+      updateCurrentEntityId: updateCurrentEntityId,
+      handleTabModeChange: handleTabModeChange,
+      getUserDetails: getUserDetails,
+      hasPrivilege: hasPrivilege,
+      updateActiveTab: updateActiveTab,
+      updateActiveSubTab: updateActiveSubTab,
+      updateTabProperty: updateTabProperty,
+      updateTabs: updateTabs,
+      homeUrl: homeUrl,
+      preventHomeRedirect: preventHomeRedirect,
+      hiddenExternalToolbars: hiddenExternalToolbars,
+      showExternalToolbar: showExternalToolbar,
+      hideExternalToolbar: hideExternalToolbar,
+      tabModePreference: tabModePreference,
+      discardSubTabWrapperWidth: discardSubTabWrapperWidth,
+      isMobileView: isMobileView,
+      isDefaultExpanded: isDefaultExpanded
+    }
+  }, children);
+}
+function useTabContext() {
+  return (0, _react.useContext)(TabContext);
+}