redux-astroglide 0.1.21 → 0.1.24

package/dist/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react-redux')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react-redux'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["redux-astroglide"] = {}, global.reactRedux));
-})(this, (function (exports, reactRedux) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["redux-astroglide"] = {}));
+})(this, (function (exports) { 'use strict';
 
   function _arrayLikeToArray(r, a) {
     (null == a || a > r.length) && (a = r.length);
@@ -5625,23 +5625,6 @@
   var upperFirst = createCaseFirst('toUpperCase');
   var upperFirst_1 = upperFirst;
 
-  const callbackObj = {
-    onAddMiddleware: () => {
-      throw Error("You can't inject middleware until after the store has been initialized.");
-    }
-  };
-  const injectMiddleware = middleware => {
-    callbackObj.onAddMiddleware(middleware);
-  };
-  const injectableMiddleware = store => _next => {
-    let next = _next;
-    callbackObj.onAddMiddleware = middleware => {
-      const currentNextFn = next;
-      next = compose(middleware(store))(currentNextFn); // wrap the previous `next` function with this new one, a la redux
-    };
-    return action => next(action);
-  };
-
   var react = {exports: {}};
 
   var react_production_min = {};
@@ -8417,11 +8400,378 @@
     }
   })(react);
 
+  var withSelector = {exports: {}};
+
+  var useSyncExternalStoreWithSelector_production = {};
+
+  /**
+   * @license React
+   * use-sync-external-store-with-selector.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  var hasRequiredUseSyncExternalStoreWithSelector_production;
+  function requireUseSyncExternalStoreWithSelector_production() {
+    if (hasRequiredUseSyncExternalStoreWithSelector_production) return useSyncExternalStoreWithSelector_production;
+    hasRequiredUseSyncExternalStoreWithSelector_production = 1;
+    var React = react.exports;
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    var objectIs = "function" === typeof Object.is ? Object.is : is,
+      useSyncExternalStore = React.useSyncExternalStore,
+      useRef = React.useRef,
+      useEffect = React.useEffect,
+      useMemo = React.useMemo,
+      useDebugValue = React.useDebugValue;
+    useSyncExternalStoreWithSelector_production.useSyncExternalStoreWithSelector = function (subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+      var instRef = useRef(null);
+      if (null === instRef.current) {
+        var inst = {
+          hasValue: !1,
+          value: null
+        };
+        instRef.current = inst;
+      } else inst = instRef.current;
+      instRef = useMemo(function () {
+        function memoizedSelector(nextSnapshot) {
+          if (!hasMemo) {
+            hasMemo = !0;
+            memoizedSnapshot = nextSnapshot;
+            nextSnapshot = selector(nextSnapshot);
+            if (void 0 !== isEqual && inst.hasValue) {
+              var currentSelection = inst.value;
+              if (isEqual(currentSelection, nextSnapshot)) return memoizedSelection = currentSelection;
+            }
+            return memoizedSelection = nextSnapshot;
+          }
+          currentSelection = memoizedSelection;
+          if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+          var nextSelection = selector(nextSnapshot);
+          if (void 0 !== isEqual && isEqual(currentSelection, nextSelection)) return memoizedSnapshot = nextSnapshot, currentSelection;
+          memoizedSnapshot = nextSnapshot;
+          return memoizedSelection = nextSelection;
+        }
+        var hasMemo = !1,
+          memoizedSnapshot,
+          memoizedSelection,
+          maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+        return [function () {
+          return memoizedSelector(getSnapshot());
+        }, null === maybeGetServerSnapshot ? void 0 : function () {
+          return memoizedSelector(maybeGetServerSnapshot());
+        }];
+      }, [getSnapshot, getServerSnapshot, selector, isEqual]);
+      var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+      useEffect(function () {
+        inst.hasValue = !0;
+        inst.value = value;
+      }, [value]);
+      useDebugValue(value);
+      return value;
+    };
+    return useSyncExternalStoreWithSelector_production;
+  }
+
+  var useSyncExternalStoreWithSelector_development = {};
+
+  /**
+   * @license React
+   * use-sync-external-store-with-selector.development.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  var hasRequiredUseSyncExternalStoreWithSelector_development;
+  function requireUseSyncExternalStoreWithSelector_development() {
+    if (hasRequiredUseSyncExternalStoreWithSelector_development) return useSyncExternalStoreWithSelector_development;
+    hasRequiredUseSyncExternalStoreWithSelector_development = 1;
+    "production" !== process.env.NODE_ENV && function () {
+      function is(x, y) {
+        return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var React = react.exports,
+        objectIs = "function" === typeof Object.is ? Object.is : is,
+        useSyncExternalStore = React.useSyncExternalStore,
+        useRef = React.useRef,
+        useEffect = React.useEffect,
+        useMemo = React.useMemo,
+        useDebugValue = React.useDebugValue;
+      useSyncExternalStoreWithSelector_development.useSyncExternalStoreWithSelector = function (subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+        var instRef = useRef(null);
+        if (null === instRef.current) {
+          var inst = {
+            hasValue: !1,
+            value: null
+          };
+          instRef.current = inst;
+        } else inst = instRef.current;
+        instRef = useMemo(function () {
+          function memoizedSelector(nextSnapshot) {
+            if (!hasMemo) {
+              hasMemo = !0;
+              memoizedSnapshot = nextSnapshot;
+              nextSnapshot = selector(nextSnapshot);
+              if (void 0 !== isEqual && inst.hasValue) {
+                var currentSelection = inst.value;
+                if (isEqual(currentSelection, nextSnapshot)) return memoizedSelection = currentSelection;
+              }
+              return memoizedSelection = nextSnapshot;
+            }
+            currentSelection = memoizedSelection;
+            if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+            var nextSelection = selector(nextSnapshot);
+            if (void 0 !== isEqual && isEqual(currentSelection, nextSelection)) return memoizedSnapshot = nextSnapshot, currentSelection;
+            memoizedSnapshot = nextSnapshot;
+            return memoizedSelection = nextSelection;
+          }
+          var hasMemo = !1,
+            memoizedSnapshot,
+            memoizedSelection,
+            maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+          return [function () {
+            return memoizedSelector(getSnapshot());
+          }, null === maybeGetServerSnapshot ? void 0 : function () {
+            return memoizedSelector(maybeGetServerSnapshot());
+          }];
+        }, [getSnapshot, getServerSnapshot, selector, isEqual]);
+        var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+        useEffect(function () {
+          inst.hasValue = !0;
+          inst.value = value;
+        }, [value]);
+        useDebugValue(value);
+        return value;
+      };
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    }();
+    return useSyncExternalStoreWithSelector_development;
+  }
+
+  (function (module) {
+
+    if (process.env.NODE_ENV === 'production') {
+      module.exports = requireUseSyncExternalStoreWithSelector_production();
+    } else {
+      module.exports = requireUseSyncExternalStoreWithSelector_development();
+    }
+  })(withSelector);
+
+  // src/utils/react.ts
+
+  // src/utils/shallowEqual.ts
+  function is(x, y) {
+    if (x === y) {
+      return x !== 0 || y !== 0 || 1 / x === 1 / y;
+    } else {
+      return x !== x && y !== y;
+    }
+  }
+  function shallowEqual(objA, objB) {
+    if (is(objA, objB)) return true;
+    if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
+      return false;
+    }
+    const keysA = Object.keys(objA);
+    const keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) return false;
+    for (let i = 0; i < keysA.length; i++) {
+      if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // src/components/Context.ts
+  var ContextKey = /* @__PURE__ */ Symbol.for(`react-redux-context`);
+  var gT = typeof globalThis !== "undefined" ? globalThis : (
+    /* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */
+    {}
+  );
+  function getContext() {
+    if (!react.exports.createContext) return {};
+    const contextMap = gT[ContextKey] ??= /* @__PURE__ */ new Map();
+    let realContext = contextMap.get(react.exports.createContext);
+    if (!realContext) {
+      realContext = react.exports.createContext(
+        null
+      );
+      if (process.env.NODE_ENV !== "production") {
+        realContext.displayName = "ReactRedux";
+      }
+      contextMap.set(react.exports.createContext, realContext);
+    }
+    return realContext;
+  }
+  var ReactReduxContext = /* @__PURE__ */ getContext();
+
+  // src/hooks/useReduxContext.ts
+  function createReduxContextHook(context = ReactReduxContext) {
+    return function useReduxContext2() {
+      const contextValue = react.exports.useContext(context);
+      if (process.env.NODE_ENV !== "production" && !contextValue) {
+        throw new Error(
+          "could not find react-redux context value; please ensure the component is wrapped in a <Provider>"
+        );
+      }
+      return contextValue;
+    };
+  }
+  var useReduxContext = /* @__PURE__ */ createReduxContextHook();
+
+  // src/hooks/useStore.ts
+  function createStoreHook(context = ReactReduxContext) {
+    const useReduxContext2 = context === ReactReduxContext ? useReduxContext : (
+      // @ts-ignore
+      createReduxContextHook(context)
+    );
+    const useStore2 = () => {
+      const { store } = useReduxContext2();
+      return store;
+    };
+    Object.assign(useStore2, {
+      withTypes: () => useStore2
+    });
+    return useStore2;
+  }
+  var useStore = /* @__PURE__ */ createStoreHook();
+
+  // src/hooks/useDispatch.ts
+  function createDispatchHook(context = ReactReduxContext) {
+    const useStore2 = context === ReactReduxContext ? useStore : createStoreHook(context);
+    const useDispatch2 = () => {
+      const store = useStore2();
+      return store.dispatch;
+    };
+    Object.assign(useDispatch2, {
+      withTypes: () => useDispatch2
+    });
+    return useDispatch2;
+  }
+  var useDispatch = /* @__PURE__ */ createDispatchHook();
+  var refEquality = (a, b) => a === b;
+  function createSelectorHook$1(context = ReactReduxContext) {
+    const useReduxContext2 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context);
+    const useSelector2 = (selector, equalityFnOrOptions = {}) => {
+      const { equalityFn = refEquality } = typeof equalityFnOrOptions === "function" ? { equalityFn: equalityFnOrOptions } : equalityFnOrOptions;
+      if (process.env.NODE_ENV !== "production") {
+        if (!selector) {
+          throw new Error(`You must pass a selector to useSelector`);
+        }
+        if (typeof selector !== "function") {
+          throw new Error(`You must pass a function as a selector to useSelector`);
+        }
+        if (typeof equalityFn !== "function") {
+          throw new Error(
+            `You must pass a function as an equality function to useSelector`
+          );
+        }
+      }
+      const reduxContext = useReduxContext2();
+      const { store, subscription, getServerState } = reduxContext;
+      const firstRun = react.exports.useRef(true);
+      const wrappedSelector = react.exports.useCallback(
+        {
+          [selector.name](state) {
+            const selected = selector(state);
+            if (process.env.NODE_ENV !== "production") {
+              const { devModeChecks = {} } = typeof equalityFnOrOptions === "function" ? {} : equalityFnOrOptions;
+              const { identityFunctionCheck, stabilityCheck } = reduxContext;
+              const {
+                identityFunctionCheck: finalIdentityFunctionCheck,
+                stabilityCheck: finalStabilityCheck
+              } = {
+                stabilityCheck,
+                identityFunctionCheck,
+                ...devModeChecks
+              };
+              if (finalStabilityCheck === "always" || finalStabilityCheck === "once" && firstRun.current) {
+                const toCompare = selector(state);
+                if (!equalityFn(selected, toCompare)) {
+                  let stack = void 0;
+                  try {
+                    throw new Error();
+                  } catch (e) {
+                    ({ stack } = e);
+                  }
+                  console.warn(
+                    "Selector " + (selector.name || "unknown") + " returned a different result when called with the same parameters. This can lead to unnecessary rerenders.\nSelectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization",
+                    {
+                      state,
+                      selected,
+                      selected2: toCompare,
+                      stack
+                    }
+                  );
+                }
+              }
+              if (finalIdentityFunctionCheck === "always" || finalIdentityFunctionCheck === "once" && firstRun.current) {
+                if (selected === state) {
+                  let stack = void 0;
+                  try {
+                    throw new Error();
+                  } catch (e) {
+                    ({ stack } = e);
+                  }
+                  console.warn(
+                    "Selector " + (selector.name || "unknown") + " returned the root state when called. This can lead to unnecessary rerenders.\nSelectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.",
+                    { stack }
+                  );
+                }
+              }
+              if (firstRun.current) firstRun.current = false;
+            }
+            return selected;
+          }
+        }[selector.name],
+        [selector]
+      );
+      const selectedState = withSelector.exports.useSyncExternalStoreWithSelector(
+        subscription.addNestedSub,
+        store.getState,
+        getServerState || store.getState,
+        wrappedSelector,
+        equalityFn
+      );
+      react.exports.useDebugValue(selectedState);
+      return selectedState;
+    };
+    Object.assign(useSelector2, {
+      withTypes: () => useSelector2
+    });
+    return useSelector2;
+  }
+  var useSelector = /* @__PURE__ */ createSelectorHook$1();
+
+  const callbackObj = {
+    onAddMiddleware: () => {
+      throw Error("You can't inject middleware until after the store has been initialized.");
+    }
+  };
+  const injectMiddleware = middleware => {
+    callbackObj.onAddMiddleware(middleware);
+  };
+  const injectableMiddleware = store => _next => {
+    let next = _next;
+    callbackObj.onAddMiddleware = middleware => {
+      const currentNextFn = next;
+      next = compose(middleware(store))(currentNextFn); // wrap the previous `next` function with this new one, a la redux
+    };
+    return action => next(action);
+  };
+
   var useAction = function useAction(action, deps) {
     return useActions([action], deps)[0];
   };
   var useActions = function useActions(actions, deps) {
-    var dispatch = reactRedux.useDispatch();
+    var dispatch = useDispatch();
     return react.exports.useMemo(function () {
       if (Array.isArray(actions)) {
         return actions.map(function (a) {
@@ -8553,12 +8903,12 @@
 
   var makeSelectorHook = function makeSelectorHook(selector) {
     return function () {
-      return reactRedux.useSelector(selector, reactRedux.shallowEqual);
+      return useSelector(selector, shallowEqual);
     };
   };
   var createSelectorUpdateHook = function createSelectorUpdateHook(selector, action) {
     return function () {
-      return [reactRedux.useSelector(selector), useAction(action, undefined)];
+      return [useSelector(selector), useAction(action, undefined)];
     };
   };
   var createSelectorHook = function createSelectorHook() {
@@ -8626,7 +8976,7 @@
         var setterCb = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function (value) {
           return value;
         };
-        return [reactRedux.useSelector(selector), useAction(function (value) {
+        return [useSelector(selector), useAction(function (value) {
           return updateAction(setterCb(value));
         }, undefined)];
       };
@@ -8658,15 +9008,86 @@
 
   var _excluded = ["middleware", "devTools", "preloadedState", "enhancers"],
     _excluded2 = ["selectDomain"];
-  var configure = function configure(_ref) {
-    var _middleware = _ref.middleware,
+
+  // ============================================================================
+  // Utility Types
+  // ============================================================================
+
+  /** Capitalize first letter of a string type */
+
+  // ============================================================================
+  // Hook Types
+  // ============================================================================
+
+  /** Return type for hooks - [value, setter, extras] */
+
+  /** A hook with static methods for non-component usage */
+
+  /** Generate hook types from initial state - creates useFieldName for each field */
+
+  /** Domain hook for the entire slice state */
+
+  // ============================================================================
+  // Selector Types
+  // ============================================================================
+
+  /** Generate selector types from initial state - creates selectFieldName for each field */
+
+  // ============================================================================
+  // Action Types
+  // ============================================================================
+
+  /** Generate setter action types from initial state - creates setFieldName for each field */
+
+  /** Slice-level setter action */
+
+  /** Extract action types from custom reducers */
+
+  // ============================================================================
+  // Extended Slice Type
+  // ============================================================================
+
+  /** Extended slice with hooks, selectors, and properly typed actions */
+
+  // ============================================================================
+  // Configure Options Types
+  // ============================================================================
+
+  /** Configuration options for the store - reducer is NOT required */
+
+  // ============================================================================
+  // RTK Config Types
+  // ============================================================================
+
+  /** RTK-compatible configuration for custom reducers */
+
+  /** Astroglide-specific configuration overrides */
+
+  // ============================================================================
+  // Configure Result Type
+  // ============================================================================
+
+  /** Result returned from configure() */
+
+  var configure = function configure() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _middleware = _ref.middleware,
       devTools = _ref.devTools,
       preloadedState = _ref.preloadedState,
       enhancers = _ref.enhancers,
       staticReducers = _objectWithoutProperties(_ref, _excluded);
+    // Add a placeholder reducer if no static reducers provided
+    // This prevents combineReducers({}) from throwing an error
+    var hasStaticReducers = Object.keys(staticReducers).length > 0;
+    var initialReducers = hasStaticReducers ? staticReducers : {
+      __astroglide_init__: function __astroglide_init__() {
+        var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        return state;
+      }
+    };
     var store = configureStore({
       // @ts-ignore-next-line
-      reducer: combineReducers(staticReducers),
+      reducer: combineReducers(initialReducers),
       middleware: function middleware(getDefaultMiddleware) {
         return [].concat(_toConsumableArray(typeof _middleware === "function" ? _middleware(getDefaultMiddleware) : _middleware || []), [injectableMiddleware]);
       },
@@ -8677,12 +9098,13 @@
     var _configureSelectors = configure$1(store),
       makePropertySelectorsFromSlice = _configureSelectors.makePropertySelectorsFromSlice;
     var injectSlice$1 = function injectSlice$1(slice) {
-      return injectSlice(store, staticReducers, slice);
+      return injectSlice(store, initialReducers, slice);
     };
     var injectReducer$1 = function injectReducer$1(key, asyncReducer) {
-      return injectReducer(store, staticReducers, key, asyncReducer);
+      return injectReducer(store, initialReducers, key, asyncReducer);
     };
-    var createAutomatedSlice = function createAutomatedSlice(sliceConfig, rtkConfig) {
+    var createAutomatedSlice = function createAutomatedSlice(sliceConfig) {
+      var rtkConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var pluginData = {};
       map_1(sliceConfig.initialState, function (_item, key) {
         var item = _item; // cache it here to pull item -> value -> value -> value if multiple plugins are used...
@@ -8738,18 +9160,18 @@
             return action.payload;
           }
         }, sliceSetterKey, function (state, action) {
-          var _loop = function _loop(key) {
-            var actionType = "set".concat(upperFirst_1(key));
+          var _loop = function _loop(_key) {
+            var actionType = "set".concat(upperFirst_1(_key));
             var setter = setterReducers[actionType] || function (_state, _action) {
-              _state[key] = _action.payload;
+              _state[_key] = _action.payload;
             };
             setter(state, {
               type: actionType,
-              payload: action.payload[key]
+              payload: action.payload[_key]
             });
           };
-          for (var key in action.payload) {
-            _loop(key);
+          for (var _key in action.payload) {
+            _loop(_key);
           }
         }), sliceConfig.reducers || {})
       }));
@@ -8762,8 +9184,8 @@
         domainHookKey = domainHookKey.replace(/(^use)(.*)(Slice$)/, "$1$2_$3");
       }
       var getParams = function getParams() {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
+        for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
+          args[_key2] = arguments[_key2];
         }
         var params = args;
         if (args.length === 1 && typeof args[0] === "function") {
@@ -8782,7 +9204,7 @@
 
       /* eslint-disable react-hooks/rules-of-hooks */
       hooks[domainHookKey] = function () {
-        return [reactRedux.useSelector(selectDomain), useAction(slice.actions[sliceSetterKey], undefined).apply(void 0, _toConsumableArray(getParams())),
+        return [useSelector(selectDomain), useAction(slice.actions[sliceSetterKey], undefined).apply(void 0, _toConsumableArray(getParams())),
         // prop updater
         useAction(slice.actions.__override__slice__caution, undefined) // state overwriter
         ];
@@ -8802,16 +9224,24 @@
       injectSlice$1(slice);
       return slice;
     };
-    var astroglide = function astroglide(name, initialState) {
+
+    // Overload signatures for the astroglide/createSlice function
+
+    function astroglide(name) {
+      var initialState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var rtkConfig = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
       var astroglideConfigOverrides = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
       var shorthandParams = _typeof$1(name) === "object";
+
+      // Restore original parameter passing logic exactly
       var params = [].concat(_toConsumableArray(shorthandParams ? [name, initialState, rtkConfig] : [_objectSpread2$1(_objectSpread2$1({}, rtkConfig), {}, {
         name: name,
         initialState: initialState
       })]), [shorthandParams ? astroglideConfigOverrides : initialState]);
+
+      // @ts-ignore - params is dynamically constructed based on shorthand vs normal call
       return createAutomatedSlice.apply(void 0, _toConsumableArray(params));
-    };
+    }
     return {
       createSlice: astroglide,
       astroglide: astroglide,
@@ -8822,6 +9252,8 @@
     };
   };
 
+  // Export types for consumer usage
+
   exports.addPlugin = addPlugin;
   exports.addPlugins = addPlugins;
   exports.configure = configure;