@xapp/chat-widget 1.74.2 → 1.74.3

package/dist/index.es.js

@@ -1,8 +1,6 @@
 import React$1, { createContext, useMemo, useContext, useRef, useEffect, useCallback, useState, useLayoutEffect } from 'react';
 export { default as React } from 'react';
 import { useSelector, useDispatch, Provider } from 'react-redux';
-import { createStore, applyMiddleware, compose } from 'redux';
-import * as thunk from 'redux-thunk';
 
 var ActionButton = function (_a) {
     var label = _a.label, disable = _a.disable, type = _a.type, addClass = _a.addClass, onClick = _a.onClick;
@@ -31484,6 +31482,433 @@ var ChatWidget = function (props) {
         React$1.createElement(ChatButton, { addClass: getVisibilityClass(), onClick: chatButtonOnClick, config: config === null || config === void 0 ? void 0 : config.cta, imageUrl: (_2 = config === null || config === void 0 ? void 0 : config.chatButton) === null || _2 === void 0 ? void 0 : _2.imageUrl, visible: visible })));
 };
 
+// src/utils/formatProdErrorMessage.ts
+function formatProdErrorMessage$1(code) {
+  return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
+}
+
+// src/utils/symbol-observable.ts
+var $$observable = /* @__PURE__ */ (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
+var symbol_observable_default = $$observable;
+
+// src/utils/actionTypes.ts
+var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
+var ActionTypes = {
+  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
+  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
+  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
+};
+var actionTypes_default = ActionTypes;
+
+// src/utils/isPlainObject.ts
+function isPlainObject(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  let proto = obj;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
+}
+
+// src/createStore.ts
+function createStore(reducer, preloadedState, enhancer) {
+  if (typeof reducer !== "function") {
+    throw new Error(formatProdErrorMessage$1(2) );
+  }
+  if (typeof preloadedState === "function" && typeof enhancer === "function" || typeof enhancer === "function" && typeof arguments[3] === "function") {
+    throw new Error(formatProdErrorMessage$1(0) );
+  }
+  if (typeof preloadedState === "function" && typeof enhancer === "undefined") {
+    enhancer = preloadedState;
+    preloadedState = void 0;
+  }
+  if (typeof enhancer !== "undefined") {
+    if (typeof enhancer !== "function") {
+      throw new Error(formatProdErrorMessage$1(1) );
+    }
+    return enhancer(createStore)(reducer, preloadedState);
+  }
+  let currentReducer = reducer;
+  let currentState = preloadedState;
+  let currentListeners = /* @__PURE__ */ new Map();
+  let nextListeners = currentListeners;
+  let listenerIdCounter = 0;
+  let isDispatching = false;
+  function ensureCanMutateNextListeners() {
+    if (nextListeners === currentListeners) {
+      nextListeners = /* @__PURE__ */ new Map();
+      currentListeners.forEach((listener, key) => {
+        nextListeners.set(key, listener);
+      });
+    }
+  }
+  function getState() {
+    if (isDispatching) {
+      throw new Error(formatProdErrorMessage$1(3) );
+    }
+    return currentState;
+  }
+  function subscribe(listener) {
+    if (typeof listener !== "function") {
+      throw new Error(formatProdErrorMessage$1(4) );
+    }
+    if (isDispatching) {
+      throw new Error(formatProdErrorMessage$1(5) );
+    }
+    let isSubscribed = true;
+    ensureCanMutateNextListeners();
+    const listenerId = listenerIdCounter++;
+    nextListeners.set(listenerId, listener);
+    return function unsubscribe() {
+      if (!isSubscribed) {
+        return;
+      }
+      if (isDispatching) {
+        throw new Error(formatProdErrorMessage$1(6) );
+      }
+      isSubscribed = false;
+      ensureCanMutateNextListeners();
+      nextListeners.delete(listenerId);
+      currentListeners = null;
+    };
+  }
+  function dispatch(action) {
+    if (!isPlainObject(action)) {
+      throw new Error(formatProdErrorMessage$1(7) );
+    }
+    if (typeof action.type === "undefined") {
+      throw new Error(formatProdErrorMessage$1(8) );
+    }
+    if (typeof action.type !== "string") {
+      throw new Error(formatProdErrorMessage$1(17) );
+    }
+    if (isDispatching) {
+      throw new Error(formatProdErrorMessage$1(9) );
+    }
+    try {
+      isDispatching = true;
+      currentState = currentReducer(currentState, action);
+    } finally {
+      isDispatching = false;
+    }
+    const listeners = currentListeners = nextListeners;
+    listeners.forEach((listener) => {
+      listener();
+    });
+    return action;
+  }
+  function replaceReducer(nextReducer) {
+    if (typeof nextReducer !== "function") {
+      throw new Error(formatProdErrorMessage$1(10) );
+    }
+    currentReducer = nextReducer;
+    dispatch({
+      type: actionTypes_default.REPLACE
+    });
+  }
+  function observable() {
+    const outerSubscribe = subscribe;
+    return {
+      /**
+       * The minimal observable subscription method.
+       * @param observer Any object that can be used as an observer.
+       * The observer object should have a `next` method.
+       * @returns An object with an `unsubscribe` method that can
+       * be used to unsubscribe the observable from the store, and prevent further
+       * emission of values from the observable.
+       */
+      subscribe(observer) {
+        if (typeof observer !== "object" || observer === null) {
+          throw new Error(formatProdErrorMessage$1(11) );
+        }
+        function observeState() {
+          const observerAsObserver = observer;
+          if (observerAsObserver.next) {
+            observerAsObserver.next(getState());
+          }
+        }
+        observeState();
+        const unsubscribe = outerSubscribe(observeState);
+        return {
+          unsubscribe
+        };
+      },
+      [symbol_observable_default]() {
+        return this;
+      }
+    };
+  }
+  dispatch({
+    type: actionTypes_default.INIT
+  });
+  const store = {
+    dispatch,
+    subscribe,
+    getState,
+    replaceReducer,
+    [symbol_observable_default]: observable
+  };
+  return store;
+}
+function assertReducerShape(reducers) {
+  Object.keys(reducers).forEach((key) => {
+    const reducer = reducers[key];
+    const initialState = reducer(void 0, {
+      type: actionTypes_default.INIT
+    });
+    if (typeof initialState === "undefined") {
+      throw new Error(formatProdErrorMessage$1(12) );
+    }
+    if (typeof reducer(void 0, {
+      type: actionTypes_default.PROBE_UNKNOWN_ACTION()
+    }) === "undefined") {
+      throw new Error(formatProdErrorMessage$1(13) );
+    }
+  });
+}
+function combineReducers(reducers) {
+  const reducerKeys = Object.keys(reducers);
+  const finalReducers = {};
+  for (let i = 0; i < reducerKeys.length; i++) {
+    const key = reducerKeys[i];
+    if (typeof reducers[key] === "function") {
+      finalReducers[key] = reducers[key];
+    }
+  }
+  const finalReducerKeys = Object.keys(finalReducers);
+  let shapeAssertionError;
+  try {
+    assertReducerShape(finalReducers);
+  } catch (e) {
+    shapeAssertionError = e;
+  }
+  return function combination(state = {}, action) {
+    if (shapeAssertionError) {
+      throw shapeAssertionError;
+    }
+    let hasChanged = false;
+    const nextState = {};
+    for (let i = 0; i < finalReducerKeys.length; i++) {
+      const key = finalReducerKeys[i];
+      const reducer = finalReducers[key];
+      const previousStateForKey = state[key];
+      const nextStateForKey = reducer(previousStateForKey, action);
+      if (typeof nextStateForKey === "undefined") {
+        action && action.type;
+        throw new Error(formatProdErrorMessage$1(14) );
+      }
+      nextState[key] = nextStateForKey;
+      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
+    }
+    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
+    return hasChanged ? nextState : state;
+  };
+}
+
+// src/compose.ts
+function compose(...funcs) {
+  if (funcs.length === 0) {
+    return (arg) => arg;
+  }
+  if (funcs.length === 1) {
+    return funcs[0];
+  }
+  return funcs.reduce((a, b) => (...args) => a(b(...args)));
+}
+
+// src/applyMiddleware.ts
+function applyMiddleware(...middlewares) {
+  return (createStore2) => (reducer, preloadedState) => {
+    const store = createStore2(reducer, preloadedState);
+    let dispatch = () => {
+      throw new Error(formatProdErrorMessage$1(15) );
+    };
+    const middlewareAPI = {
+      getState: store.getState,
+      dispatch: (action, ...args) => dispatch(action, ...args)
+    };
+    const chain = middlewares.map((middleware) => middleware(middlewareAPI));
+    dispatch = compose(...chain)(store.dispatch);
+    return {
+      ...store,
+      dispatch
+    };
+  };
+}
+
+// src/index.ts
+function createThunkMiddleware(extraArgument) {
+  const middleware = ({ dispatch, getState }) => (next) => (action) => {
+    if (typeof action === "function") {
+      return action(dispatch, getState, extraArgument);
+    }
+    return next(action);
+  };
+  return middleware;
+}
+var thunk = createThunkMiddleware();
+var withExtraArgument = createThunkMiddleware;
+
+// src/index.ts
+var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
+  if (arguments.length === 0) return void 0;
+  if (typeof arguments[0] === "object") return compose;
+  return compose.apply(null, arguments);
+};
+var Tuple = class _Tuple extends Array {
+  constructor(...items) {
+    super(...items);
+    Object.setPrototypeOf(this, _Tuple.prototype);
+  }
+  static get [Symbol.species]() {
+    return _Tuple;
+  }
+  concat(...arr) {
+    return super.concat.apply(this, arr);
+  }
+  prepend(...arr) {
+    if (arr.length === 1 && Array.isArray(arr[0])) {
+      return new _Tuple(...arr[0].concat(this));
+    }
+    return new _Tuple(...arr.concat(this));
+  }
+};
+
+// src/getDefaultMiddleware.ts
+function isBoolean(x) {
+  return typeof x === "boolean";
+}
+var buildGetDefaultMiddleware = () => function getDefaultMiddleware(options) {
+  const {
+    thunk: thunk$1 = true,
+    immutableCheck = true,
+    serializableCheck = true,
+    actionCreatorCheck = true
+  } = options ?? {};
+  let middlewareArray = new Tuple();
+  if (thunk$1) {
+    if (isBoolean(thunk$1)) {
+      middlewareArray.push(thunk);
+    } else {
+      middlewareArray.push(withExtraArgument(thunk$1.extraArgument));
+    }
+  }
+  return middlewareArray;
+};
+
+// src/autoBatchEnhancer.ts
+var SHOULD_AUTOBATCH = "RTK_autoBatch";
+var createQueueWithTimer = (timeout) => {
+  return (notify) => {
+    setTimeout(notify, timeout);
+  };
+};
+var rAF = typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame : createQueueWithTimer(10);
+var autoBatchEnhancer = (options = {
+  type: "raf"
+}) => (next) => (...args) => {
+  const store = next(...args);
+  let notifying = true;
+  let shouldNotifyAtEndOfTick = false;
+  let notificationQueued = false;
+  const listeners = /* @__PURE__ */ new Set();
+  const queueCallback = options.type === "tick" ? queueMicrotask : options.type === "raf" ? rAF : options.type === "callback" ? options.queueNotification : createQueueWithTimer(options.timeout);
+  const notifyListeners = () => {
+    notificationQueued = false;
+    if (shouldNotifyAtEndOfTick) {
+      shouldNotifyAtEndOfTick = false;
+      listeners.forEach((l) => l());
+    }
+  };
+  return Object.assign({}, store, {
+    // Override the base `store.subscribe` method to keep original listeners
+    // from running if we're delaying notifications
+    subscribe(listener2) {
+      const wrappedListener = () => notifying && listener2();
+      const unsubscribe = store.subscribe(wrappedListener);
+      listeners.add(listener2);
+      return () => {
+        unsubscribe();
+        listeners.delete(listener2);
+      };
+    },
+    // Override the base `store.dispatch` method so that we can check actions
+    // for the `shouldAutoBatch` flag and determine if batching is active
+    dispatch(action) {
+      try {
+        notifying = !action?.meta?.[SHOULD_AUTOBATCH];
+        shouldNotifyAtEndOfTick = !notifying;
+        if (shouldNotifyAtEndOfTick) {
+          if (!notificationQueued) {
+            notificationQueued = true;
+            queueCallback(notifyListeners);
+          }
+        }
+        return store.dispatch(action);
+      } finally {
+        notifying = true;
+      }
+    }
+  });
+};
+
+// src/getDefaultEnhancers.ts
+var buildGetDefaultEnhancers = (middlewareEnhancer) => function getDefaultEnhancers(options) {
+  const {
+    autoBatch = true
+  } = options ?? {};
+  let enhancerArray = new Tuple(middlewareEnhancer);
+  if (autoBatch) {
+    enhancerArray.push(autoBatchEnhancer(typeof autoBatch === "object" ? autoBatch : void 0));
+  }
+  return enhancerArray;
+};
+
+// src/configureStore.ts
+function configureStore(options) {
+  const getDefaultMiddleware = buildGetDefaultMiddleware();
+  const {
+    reducer = void 0,
+    middleware,
+    devTools = true,
+    preloadedState = void 0,
+    enhancers = void 0
+  } = options || {};
+  let rootReducer;
+  if (typeof reducer === "function") {
+    rootReducer = reducer;
+  } else if (isPlainObject(reducer)) {
+    rootReducer = combineReducers(reducer);
+  } else {
+    throw new Error(formatProdErrorMessage(1) );
+  }
+  let finalMiddleware;
+  if (typeof middleware === "function") {
+    finalMiddleware = middleware(getDefaultMiddleware);
+  } else {
+    finalMiddleware = getDefaultMiddleware();
+  }
+  let finalCompose = compose;
+  if (devTools) {
+    finalCompose = composeWithDevTools({
+      // Enable capture of stack traces for dispatched Redux actions
+      trace: "production" !== "production",
+      ...typeof devTools === "object" && devTools
+    });
+  }
+  const middlewareEnhancer = applyMiddleware(...finalMiddleware);
+  const getDefaultEnhancers = buildGetDefaultEnhancers(middlewareEnhancer);
+  let storeEnhancers = typeof enhancers === "function" ? enhancers(getDefaultEnhancers) : getDefaultEnhancers();
+  const composedEnhancer = finalCompose(...storeEnhancers);
+  return createStore(rootReducer, preloadedState, composedEnhancer);
+}
+
+// src/formatProdErrorMessage.ts
+function formatProdErrorMessage(code) {
+  return `Minified Redux Toolkit error #${code}; visit https://redux-toolkit.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
+}
+
 function tryParseJson(str) {
     try {
         if (str) {
@@ -31663,15 +32088,12 @@ function appendMessageToState(state, msg) {
 }
 function update(state, action) {
     var _a, _b, _c, _d;
-    var _e;
+    var _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
     if (state === void 0) { state = DEFAULT_STATE; }
     log("action", action);
     if (action.type === "reset") {
         return resetReducer(state);
     }
-    if (action.detail) {
-        state.lastTimestamp = action.detail.timestamp;
-    }
     switch (action.type) {
         case "connection_update":
         case "receiveToken":
@@ -31679,39 +32101,25 @@ function update(state, action) {
             // workaround until state is split. Use combineReducers afterwards
             var newConnectionState = connectionReducer(state.connection, action);
             if (state.connection !== newConnectionState) {
-                state = __assign(__assign({}, state), { connection: newConnectionState });
+                state = __assign(__assign({}, state), { lastTimestamp: (_e = action.detail) === null || _e === void 0 ? void 0 : _e.timestamp, connection: newConnectionState });
             }
             return state;
         case "account_status":
-            return __assign(__assign({}, state), { accountStatus: action.detail.status });
+            return __assign(__assign({}, state), { lastTimestamp: (_f = action.detail) === null || _f === void 0 ? void 0 : _f.timestamp, accountStatus: action.detail.status });
         case "session_id":
-            return __assign(__assign({}, state), { sessionId: action.detail.sessionId });
+            return __assign(__assign({}, state), { lastTimestamp: (_g = action.detail) === null || _g === void 0 ? void 0 : _g.timestamp, sessionId: action.detail.sessionId });
         case "visual_status":
-            var newVisualState = __assign({}, state);
-            // Backward compatibility
-            if (!newVisualState.visuals) {
-                newVisualState.visuals = {};
-            }
-            if (action.detail.status.drawer !== undefined) {
-                newVisualState.visuals.drawer = action.detail.status.drawer;
-            }
-            if (action.detail.status.opened !== undefined) {
-                newVisualState.visuals.opened = action.detail.status.opened;
-            }
-            if (action.detail.status.visible !== undefined) {
-                newVisualState.visuals.visible = action.detail.status.visible;
-            }
-            return newVisualState;
+            return __assign(__assign({}, state), { lastTimestamp: (_h = action.detail) === null || _h === void 0 ? void 0 : _h.timestamp, visuals: __assign(__assign(__assign(__assign({}, (state.visuals || {})), (action.detail.status.drawer !== undefined && { drawer: action.detail.status.drawer })), (action.detail.status.opened !== undefined && { opened: action.detail.status.opened })), (action.detail.status.visible !== undefined && { visible: action.detail.status.visible })) });
         case "department_update":
-            return __assign(__assign({}, state), { departments: __assign(__assign({}, state.departments), (_a = {}, _a[action.detail.id] = __assign({}, action.detail), _a)) });
+            return __assign(__assign({}, state), { lastTimestamp: (_j = action.detail) === null || _j === void 0 ? void 0 : _j.timestamp, departments: __assign(__assign({}, state.departments), (_a = {}, _a[action.detail.id] = __assign({}, action.detail), _a)) });
         case "visitor_update":
-            return __assign(__assign({}, state), { visitor: __assign(__assign({}, state.visitor), action.detail) });
+            return __assign(__assign({}, state), { lastTimestamp: (_k = action.detail) === null || _k === void 0 ? void 0 : _k.timestamp, visitor: __assign(__assign({}, state.visitor), action.detail) });
         case "agent_update":
             var prevUpdateAgent = state.agents[action.detail.nick];
-            return __assign(__assign({}, state), { agents: __assign(__assign({}, state.agents), (_b = {}, _b[action.detail.nick] = __assign(__assign({}, prevUpdateAgent), { user: __assign(__assign({}, prevUpdateAgent.user), action.detail), typing: (prevUpdateAgent || { typing: false }).typing // if we had it - keep it
+            return __assign(__assign({}, state), { lastTimestamp: (_l = action.detail) === null || _l === void 0 ? void 0 : _l.timestamp, agents: __assign(__assign({}, state.agents), (_b = {}, _b[action.detail.nick] = __assign(__assign({}, prevUpdateAgent), { user: __assign(__assign({}, prevUpdateAgent.user), action.detail), typing: (prevUpdateAgent || { typing: false }).typing // if we had it - keep it
                  }), _b)) });
         case "chat":
-            var newState = __assign({}, state);
+            var newState = __assign(__assign({}, state), { lastTimestamp: (_m = action.detail) === null || _m === void 0 ? void 0 : _m.timestamp });
             switch (action.detail.type) {
                 case "chat.memberjoin":
                     return memberJoin(state, action.detail);
@@ -31731,7 +32139,7 @@ function update(state, action) {
                     appendMessageToState(newState, action.detail);
                     var detail = action.detail;
                     var msg = detail.type === "chat.msg" ? detail.msg : null;
-                    newState.chips = ((_e = msg === null || msg === void 0 ? void 0 : msg.options) === null || _e === void 0 ? void 0 : _e.length) ? msg.options : [];
+                    newState.chips = ((_o = msg === null || msg === void 0 ? void 0 : msg.options) === null || _o === void 0 ? void 0 : _o.length) ? msg.options : [];
                     return newState;
                 case "chat.failureMsg":
                     var agentDetails = newState.agents[action.detail.user.nick];
@@ -31751,7 +32159,7 @@ function update(state, action) {
                     return __assign(__assign({}, finalState), { agents: __assign(__assign({}, finalState.agents), (_c = {}, _c[action.detail.user.nick] = __assign(__assign({}, agentDetails), { typing: false, requestFailed: true }), _c)), failureMsg: action.detail.failureMsg });
                 case "chat.typing":
                     var agent = state.agents[action.detail.user.nick];
-                    return __assign(__assign({}, state), { agents: __assign(__assign({}, state.agents), (_d = {}, _d[action.detail.user.nick] = __assign(__assign({}, agent), { typing: action.detail.typing }), _d)) });
+                    return __assign(__assign({}, state), { lastTimestamp: (_p = action.detail) === null || _p === void 0 ? void 0 : _p.timestamp, agents: __assign(__assign({}, state.agents), (_d = {}, _d[action.detail.user.nick] = __assign(__assign({}, agent), { typing: action.detail.typing }), _d)) });
                 default:
                     return state;
             }
@@ -31822,9 +32230,7 @@ function createChatStore(config, dataStorage) {
     var now = new Date().getTime();
     if (joinSessionId) {
         var adminTimesData = dataStorage.getItem(ADMIN_STORE_KEY);
-        // Create
         var adminTimes = adminTimesData ? JSON.parse(adminTimesData) : {};
-        // if exists, use it. If not, check if we are maxed out. evict one session if we are.
         if (adminTimes[joinSessionId]) {
             log("ChatStore: reusing session: ".concat(joinSessionId));
             adminTimes[joinSessionId].lastAccessMs = now;
@@ -31837,7 +32243,6 @@ function createChatStore(config, dataStorage) {
                 dataStorage.removeItem(adminTimes[evictedSessionId].dataStorageKey);
                 adminTimes[evictedSessionId] = undefined;
             }
-            // We now have room
             dataStorageKey = generateKey(connection, joinSessionId);
             adminTimes[joinSessionId] = {
                 lastAccessMs: now,
@@ -31857,21 +32262,19 @@ function createChatStore(config, dataStorage) {
         sessionExpiration: config.sessionExpiration
     });
     var chatReducer = persistStateReducer(storage, defaultState, storeHandler);
-    var middlewares = [
-        thunk.default
-    ];
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    var composeEnhancers = globalThis.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;
-    return createStore(chatReducer, composeEnhancers(applyMiddleware.apply(void 0, middlewares)));
+    // Configure store with @reduxjs/toolkit
+    var store = configureStore({
+        reducer: chatReducer,
+        middleware: function (getDefaultMiddleware) {
+            return getDefaultMiddleware({
+                thunk: true,
+            });
+        },
+        devTools: "production" !== 'production', // Include dev tools in non-production environments
+    });
+    return store;
 }
-/**
- * Pick one admin session for eviction
- *
- * @param adminTimes
- * @returns
- */
 function evictAdminSession(adminTimes) {
-    // Find the oldest
     var minTimeTs = Number.MAX_VALUE;
     var minSessionId;
     for (var _i = 0, _a = Object.keys(adminTimes); _i < _a.length; _i++) {
@@ -31917,6 +32320,7 @@ var ChatWidgetContainer = function (props) {
         React$1.createElement(ChatWidgetWrapper, __assign({}, widgetProps))));
 };
 
+// Function to create a static reducer
 function createStaticReducer(state) {
     return function (oldState, action) {
         if (oldState === void 0) { oldState = state; }
@@ -31924,14 +32328,19 @@ function createStaticReducer(state) {
         return oldState;
     };
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-var composeEnhancers = (globalThis === null || globalThis === void 0 ? void 0 : globalThis.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) || compose;
-var middlewares = [
-    thunk.default
-];
+// Function to create the store using @reduxjs/toolkit's configureStore
 function createStaticStore(state) {
     var reducer = createStaticReducer(state);
-    return createStore(reducer, composeEnhancers(applyMiddleware.apply(void 0, middlewares)));
+    var store = configureStore({
+        reducer: reducer,
+        middleware: function (getDefaultMiddleware) {
+            return getDefaultMiddleware({
+                thunk: true, // Thunk is included by default, this is just for explicitness
+            });
+        },
+        devTools: "production" !== 'production', // Redux DevTools in non-production environments
+    });
+    return store;
 }
 
 var StaticChatWidgetContainer = function (props) {