pinia-react 1.5.2 → 2.0.0

package/dist/index.js

@@ -1,385 +1,392 @@
-// src/createPinia.ts
-import { effectScope, markRaw, ref } from "@maoism/runtime-core";
-
 // src/rootStore.ts
-var getActivePinia = () => activePinia;
 var activePinia;
-function setActivePinia(_pinia) {
-  activePinia = _pinia;
+function setActivePinia(pinia) {
+  activePinia = pinia;
+}
+function getActivePinia() {
+  if (!activePinia) {
+    throw new Error(
+      "[pinia-react] getActivePinia was called with no active Pinia. Did you forget to install pinia?\nconst pinia = createPinia() or createPinia() first.\n"
+    );
+  }
+  return activePinia;
 }
 
 // src/createPinia.ts
 function createPinia() {
-  const scope = effectScope(true);
-  const state = scope.run(() => ref({}));
+  const state = {};
   const _p = [];
-  const pinia = markRaw({
+  const _s = /* @__PURE__ */ new Map();
+  const _scopes = /* @__PURE__ */ new Map();
+  const pinia = {
     use(plugin) {
       _p.push(plugin);
       return this;
     },
     _p,
-    _e: scope,
-    _s: /* @__PURE__ */ new Map(),
+    _s,
+    _scopes,
     state
-  });
+  };
   setActivePinia(pinia);
   return pinia;
 }
 
 // src/store.ts
-import {
-  activeEffect,
-  computed,
-  effectScope as effectScope2,
-  markRaw as markRaw2,
-  nextTick,
-  ReactiveEffect,
-  reactive,
-  toRaw,
-  toRefs,
-  watch
-} from "@maoism/runtime-core";
-import { useCallback, useEffect, useId, useRef, useSyncExternalStore } from "react";
-
-// src/subscription.ts
-var noop = () => {
-};
-function addSubscription(activeComponentCleanUp2, subscriptions, callback, detached, onCleanup = noop) {
-  subscriptions.add(callback);
-  const removeSubscription = () => {
-    subscriptions.delete(callback);
-    onCleanup();
-  };
-  if (!detached) {
-    activeComponentCleanUp2[0].push(removeSubscription);
-  }
-  return removeSubscription;
-}
-function triggerSubscriptions(subscriptions, ...args) {
-  subscriptions.forEach((callback) => {
-    callback(...args);
-  });
-}
-
-// src/types.ts
-var MutationType = /* @__PURE__ */ ((MutationType2) => {
-  MutationType2["direct"] = "direct";
-  MutationType2["patchObject"] = "patch object";
-  MutationType2["patchFunction"] = "patch function";
-  return MutationType2;
-})(MutationType || {});
-
-// src/utils.ts
-import { isReactive, isRef } from "@maoism/runtime-core";
-function noop2() {
-  return {};
-}
-function isPlainObject(o) {
-  return o && typeof o === "object" && Object.prototype.toString.call(o) === "[object Object]" && typeof o.toJSON !== "function";
-}
-function mergeReactiveObjects(target, patchToApply) {
-  if (target instanceof Map && patchToApply instanceof Map) {
-    patchToApply.forEach((value, key) => target.set(key, value));
-  }
-  if (target instanceof Set && patchToApply instanceof Set) {
-    patchToApply.forEach(target.add, target);
-  }
-  for (const key in patchToApply) {
-    if (!Object.hasOwn(patchToApply, key)) continue;
-    const subPatch = patchToApply[key];
-    const targetValue = target[key];
-    if (isPlainObject(targetValue) && isPlainObject(subPatch) && // biome-ignore lint/suspicious/noPrototypeBuiltins: <>
-    target.hasOwnProperty(key) && !isRef(subPatch) && !isReactive(subPatch)) {
-      target[key] = mergeReactiveObjects(targetValue, subPatch);
-    } else {
-      target[key] = subPatch;
-    }
-  }
-  return target;
-}
-
-// src/store.ts
-var ACTION_MARKER = Symbol();
-var ACTION_NAME = Symbol();
-var { assign } = Object;
-function createOptionsStore(id, options, pinia) {
-  const { state, actions, getters } = options;
-  const initialState = pinia.state.value[id];
-  let store;
-  function setup() {
-    if (!initialState) {
-      pinia.state.value[id] = state ? state() : {};
+import { enablePatches, produce, setAutoFreeze } from "immer";
+import { useCallback, useRef, useSyncExternalStore } from "react";
+enablePatches();
+setAutoFreeze(false);
+var activeListenerId = null;
+var activeGetterKey = null;
+function isAffected(patches, trackedPaths) {
+  if (trackedPaths.size === 0) return false;
+  const tracked = Array.from(trackedPaths).map((p) => p.split("."));
+  for (const patch of patches) {
+    const patchPath = patch.path.map(String);
+    for (const trackedPath of tracked) {
+      const len = Math.min(patchPath.length, trackedPath.length);
+      let isPrefixMatch = true;
+      for (let i = 0; i < len; i++) {
+        if (patchPath[i] !== trackedPath[i]) {
+          isPrefixMatch = false;
+          break;
+        }
+      }
+      if (isPrefixMatch) return true;
     }
-    const localState = toRefs(pinia.state.value[id]);
-    return assign(
-      localState,
-      actions,
-      Object.keys(getters || {}).reduce(
-        (computedGetters, name) => {
-          if (name in localState) {
-            console.warn(
-              `[\u{1F34D}]: A getter cannot have the same name as another state property. Rename one of them. Found with "${name}" in store "${id}".`
-            );
-          }
-          computedGetters[name] = markRaw2(
-            computed(() => {
-              setActivePinia(pinia);
-              const store2 = pinia._s.get(id);
-              return getters[name].call(store2, store2);
-            })
-          );
-          return computedGetters;
-        },
-        {}
-      )
-    );
   }
-  store = createSetupStore(id, setup, options, pinia);
-  return store;
+  return false;
 }
-function createSetupStore($id, setup, options = {}, pinia) {
-  let scope;
-  const optionsForPlugin = assign({ actions: {} }, options);
-  const $subscribeOptions = { deep: true };
-  let isListening;
-  let isSyncListening;
-  const subscriptions = /* @__PURE__ */ new Set();
-  const actionSubscriptions = /* @__PURE__ */ new Set();
-  const debuggerEvents = [];
-  let activeListener;
-  function $patch(partialStateOrMutator) {
-    let subscriptionMutation;
-    isListening = isSyncListening = false;
-    if (typeof partialStateOrMutator === "function") {
-      partialStateOrMutator(pinia.state.value[$id]);
-      subscriptionMutation = {
-        type: "patch function" /* patchFunction */,
-        storeId: $id,
-        events: debuggerEvents
-      };
-    } else {
-      mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator);
-      subscriptionMutation = {
-        type: "patch object" /* patchObject */,
-        payload: partialStateOrMutator,
-        storeId: $id,
-        events: debuggerEvents
-      };
+function defineStore(id, options) {
+  const getters = options.getters || {};
+  function resolveGetterDependencies(getterName, getterDepsMap, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(getterName)) {
+      console.warn(`[pinia-react] Circular dependency in getters detected involving: ${getterName}`);
+      return /* @__PURE__ */ new Set();
     }
-    activeListener = Symbol();
-    const myListenerId = activeListener;
-    nextTick().then(() => {
-      if (activeListener === myListenerId) {
-        isListening = true;
+    visited.add(getterName);
+    const finalDeps = /* @__PURE__ */ new Set();
+    const directDeps = getterDepsMap.get(getterName);
+    if (!directDeps) return finalDeps;
+    for (const dep of directDeps) {
+      if (dep in getters) {
+        const nestedDeps = resolveGetterDependencies(dep, getterDepsMap, visited);
+        nestedDeps.forEach((d) => finalDeps.add(d));
+      } else {
+        finalDeps.add(dep);
       }
-    });
-    isSyncListening = true;
-    triggerSubscriptions(subscriptions, subscriptionMutation, pinia.state.value[$id]);
-  }
-  const $reset = function $reset2() {
-    const { state } = options;
-    const newState = state ? state() : {};
-    this.$patch(($state) => {
-      assign($state, newState);
-    });
-  };
-  const action = (fn, name = "") => {
-    if (ACTION_MARKER in fn) {
-      ;
-      fn[ACTION_NAME] = name;
-      return fn;
     }
-    const wrappedAction = function() {
-      setActivePinia(pinia);
-      const args = Array.from(arguments);
-      const afterCallbackSet = /* @__PURE__ */ new Set();
-      const onErrorCallbackSet = /* @__PURE__ */ new Set();
-      function after(callback) {
-        afterCallbackSet.add(callback);
-      }
-      function onError(callback) {
-        onErrorCallbackSet.add(callback);
-      }
-      triggerSubscriptions(actionSubscriptions, {
-        args,
-        name: wrappedAction[ACTION_NAME],
-        store,
-        after,
-        onError
-      });
-      let ret;
-      try {
-        ret = fn.apply(this && this.$id === $id ? this : store, args);
-      } catch (error) {
-        triggerSubscriptions(onErrorCallbackSet, error);
-        throw error;
-      }
-      if (ret instanceof Promise) {
-        return ret.then((value) => {
-          triggerSubscriptions(afterCallbackSet, value);
-          return value;
-        }).catch((error) => {
-          triggerSubscriptions(onErrorCallbackSet, error);
-          return Promise.reject(error);
+    return finalDeps;
+  }
+  function createStoreInstance() {
+    const pinia = getActivePinia();
+    const initialState = options.state();
+    let storePublicApi;
+    let devTools;
+    let isTimeTraveling = false;
+    const localScope = {
+      currentState: initialState,
+      listeners: /* @__PURE__ */ new Set(),
+      getterCache: /* @__PURE__ */ new Map(),
+      getterDependencies: /* @__PURE__ */ new Map(),
+      subscribers: /* @__PURE__ */ new Map(),
+      createStoreProxy: (_onAccess) => storePublicApi
+    };
+    pinia._scopes.set(id, localScope);
+    const isGetterComputing = /* @__PURE__ */ new Set();
+    const emit = (nextState, oldState, patches) => {
+      localScope.listeners.forEach((fn) => fn(nextState, oldState, patches));
+      localScope.subscribers.forEach((getterKeys, storeId) => {
+        const subscriberScope = pinia._scopes.get(storeId);
+        if (!subscriberScope) return;
+        let shouldNotify = false;
+        getterKeys.forEach((key) => {
+          if (subscriberScope.getterCache.has(key)) {
+            subscriberScope.getterCache.delete(key);
+            shouldNotify = true;
+          }
         });
+        if (shouldNotify) {
+          const oldSubState = subscriberScope.currentState;
+          const newSubState = { ...oldSubState };
+          subscriberScope.currentState = newSubState;
+          pinia.state[storeId] = newSubState;
+          subscriberScope.listeners.forEach((fn) => fn(newSubState, oldSubState, []));
+        }
+      });
+    };
+    const internalPatch = (updater, actionName, isReset = false) => {
+      if (isTimeTraveling) return;
+      const oldState = localScope.currentState;
+      let patches = [];
+      const nextState = produce(oldState, updater, (p) => {
+        patches = p;
+      });
+      if (patches.length > 0 || isReset) {
+        localScope.currentState = nextState;
+        pinia.state[id] = nextState;
+        if (devTools) {
+          devTools.send({ type: actionName, payload: patches }, nextState);
+        }
+        emit(nextState, oldState, patches);
       }
-      triggerSubscriptions(afterCallbackSet, ret);
-      return ret;
     };
-    wrappedAction[ACTION_MARKER] = true;
-    wrappedAction[ACTION_NAME] = name;
-    return wrappedAction;
-  };
-  const partialStore = {
-    _p: pinia,
-    // _s: scope,
-    $id,
-    $onAction: addSubscription.bind(null, activeComponentCleanUp, actionSubscriptions),
-    $patch,
-    $reset,
-    $subscribe(callback, options2 = {}) {
-      const removeSubscription = addSubscription([[]], subscriptions, callback, options2.detached, () => stopWatcher());
-      const stopWatcher = scope.run(
-        () => watch(
-          () => pinia.state.value[$id],
-          (state) => {
-            if (options2.flush === "sync" ? isSyncListening : isListening) {
-              callback(
-                {
-                  storeId: $id,
-                  type: "direct" /* direct */,
-                  events: debuggerEvents
-                },
-                state
-              );
+    const $patch = (updater) => {
+      internalPatch((draft) => {
+        updater(draft);
+      }, "@patch");
+    };
+    const $reset = () => internalPatch(() => options.state(), "@reset", true);
+    const $subscribe = (callback) => {
+      const listener = (state, prev, patches) => callback(state, prev);
+      localScope.listeners.add(listener);
+      return () => localScope.listeners.delete(listener);
+    };
+    const getterInvalidationListener = (_state, _prevState, patches) => {
+      localScope.getterDependencies.forEach((_deps, getterName) => {
+        const resolvedDeps = resolveGetterDependencies(getterName, localScope.getterDependencies);
+        if (isAffected(patches, resolvedDeps)) {
+          localScope.getterCache.delete(getterName);
+        }
+      });
+    };
+    localScope.listeners.add(getterInvalidationListener);
+    const originalActions = options.actions || {};
+    const wrappedActions = {};
+    const proxyTarget = {};
+    function createStoreProxy(onAccess) {
+      const readonlyWarning = () => {
+        console.warn(`[${id}] Store is read-only. Use actions for mutations.`);
+        return false;
+      };
+      const createStateProxy = (stateTarget, path, onDeepAccess) => {
+        return new Proxy(stateTarget, {
+          get(obj, key) {
+            if (typeof key === "symbol") return Reflect.get(obj, key);
+            const currentPath = [...path, String(key)];
+            const value = Reflect.get(obj, key);
+            if (typeof value === "object" && value !== null) {
+              return createStateProxy(value, currentPath, onDeepAccess);
             }
+            onDeepAccess?.(currentPath);
+            return value;
           },
-          assign({}, $subscribeOptions, options2)
-        )
-      );
-      return removeSubscription;
+          set: readonlyWarning
+        });
+      };
+      return new Proxy(proxyTarget, {
+        get(_target, key, receiver) {
+          const strKey = String(key);
+          if (strKey === "$state") return localScope.currentState;
+          if (strKey === "$patch") return $patch;
+          if (strKey === "$reset") return $reset;
+          if (strKey === "$subscribe") return $subscribe;
+          const state = localScope.currentState;
+          if (strKey in state) {
+            const value = state[strKey];
+            if (typeof value === "object" && value !== null) {
+              return createStateProxy(value, [strKey], onAccess);
+            }
+            onAccess?.([strKey]);
+            return value;
+          }
+          if (strKey in getters) {
+            onAccess?.([strKey]);
+            if (localScope.getterCache.has(strKey)) return localScope.getterCache.get(strKey);
+            if (isGetterComputing.has(strKey)) {
+              console.warn(`[pinia-react] Circular dependency detected in getter "${strKey}"`);
+              return void 0;
+            }
+            isGetterComputing.add(strKey);
+            const dependencies = /* @__PURE__ */ new Set();
+            const prevListenerId = activeListenerId;
+            const prevGetterKey = activeGetterKey;
+            activeListenerId = id;
+            activeGetterKey = strKey;
+            try {
+              const onGetterAccess = (path) => {
+                dependencies.add(path[0]);
+              };
+              const trackingProxyForThis = createStoreProxy(onGetterAccess);
+              const trackingStateProxy = createStateProxy(state, [], onGetterAccess);
+              const result = getters[strKey].call(trackingProxyForThis, trackingStateProxy);
+              localScope.getterDependencies.set(strKey, dependencies);
+              localScope.getterCache.set(strKey, result);
+              return result;
+            } finally {
+              activeListenerId = prevListenerId;
+              activeGetterKey = prevGetterKey;
+              isGetterComputing.delete(strKey);
+            }
+          }
+          if (strKey in wrappedActions) {
+            return wrappedActions[strKey];
+          }
+          return Reflect.get(_target, key, receiver);
+        },
+        set(_target, key, value, receiver) {
+          const strKey = String(key);
+          if (strKey === "$state") {
+            console.warn(`[${id}] Do not replace "$state" directly. Use "$patch()" to replace the whole state.`);
+            return false;
+          }
+          if (strKey in localScope.currentState || strKey in getters || strKey in wrappedActions) {
+            return readonlyWarning();
+          }
+          return Reflect.set(_target, key, value, receiver);
+        }
+      });
     }
-    // $dispose
-  };
-  const store = reactive(partialStore);
-  pinia._s.set($id, store);
-  scope = effectScope2();
-  const setupStore = scope.run(() => setup({ action }));
-  for (const key in setupStore) {
-    const prop = setupStore[key];
-    if (typeof prop === "function") {
-      const actionValue = action(prop, key);
-      setupStore[key] = actionValue;
-      optionsForPlugin.actions[key] = prop;
+    storePublicApi = createStoreProxy();
+    Object.keys(originalActions).forEach((actionName) => {
+      const originalAction = originalActions[actionName];
+      wrappedActions[actionName] = (...args) => {
+        let returnValue;
+        const recipe = (draft) => {
+          const actionContextProxy = new Proxy({}, {
+            get(_, key) {
+              const strKey = String(key);
+              if (Reflect.has(draft, strKey)) return draft[strKey];
+              if (strKey in getters) {
+                return getters[strKey].call(actionContextProxy, draft);
+              }
+              return Reflect.get(storePublicApi, key, storePublicApi);
+            },
+            set(_, key, value) {
+              ;
+              draft[String(key)] = value;
+              return true;
+            }
+          });
+          returnValue = originalAction.apply(actionContextProxy, args);
+        };
+        internalPatch(recipe, actionName);
+        return returnValue;
+      };
+    });
+    localScope.createStoreProxy = createStoreProxy;
+    pinia._p.forEach((plugin) => {
+      const pluginResult = plugin({ id, store: storePublicApi, options });
+      if (pluginResult) {
+        Object.defineProperties(proxyTarget, Object.getOwnPropertyDescriptors(pluginResult));
+      }
+    });
+    pinia._s.set(id, storePublicApi);
+    if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
+      devTools = window.__REDUX_DEVTOOLS_EXTENSION__.connect({ name: id });
+      devTools.init(localScope.currentState);
+      devTools.subscribe((message) => {
+        if (message.type === "DISPATCH") {
+          const payloadType = message.payload?.type;
+          switch (payloadType) {
+            case "JUMP_TO_STATE":
+            case "JUMP_TO_ACTION":
+            case "IMPORT_STATE": {
+              const newState = typeof message.state === "string" ? JSON.parse(message.state) : message.state;
+              if (!newState || typeof newState !== "object") return;
+              isTimeTraveling = true;
+              const oldState = localScope.currentState;
+              localScope.currentState = newState;
+              pinia.state[id] = newState;
+              localScope.getterCache.clear();
+              emit(newState, oldState, []);
+              isTimeTraveling = false;
+              break;
+            }
+            case "COMMIT": {
+              devTools.init(localScope.currentState);
+              break;
+            }
+            case "ROLLBACK": {
+              const newState = typeof message.state === "string" ? JSON.parse(message.state) : message.state;
+              if (!newState || typeof newState !== "object") return;
+              isTimeTraveling = true;
+              const oldState = localScope.currentState;
+              localScope.currentState = newState;
+              pinia.state[id] = newState;
+              localScope.getterCache.clear();
+              emit(newState, oldState, []);
+              isTimeTraveling = false;
+              break;
+            }
+            case "RESET": {
+              const originalState = options.state();
+              devTools.init(originalState);
+              internalPatch(() => originalState, "@reset", true);
+              break;
+            }
+            default:
+              break;
+          }
+        }
+      });
     }
+    return storePublicApi;
   }
-  assign(store, setupStore);
-  assign(toRaw(store), setupStore);
-  Object.defineProperty(store, "$state", {
-    get: () => pinia.state.value[$id],
-    set: (state) => {
-      $patch(($state) => {
-        assign($state, state);
-      });
+  function getStore() {
+    const pinia = getActivePinia();
+    if (!pinia._s.has(id)) {
+      createStoreInstance();
     }
-  });
-  pinia._p.forEach((extender) => {
-    assign(
-      store,
-      scope.run(
-        () => extender({
-          store,
-          pinia,
-          options: optionsForPlugin
-        })
-      )
-    );
-  });
-  isListening = true;
-  isSyncListening = true;
-  return store;
-}
-var activeComponentCleanUp = [[]];
-function defineStore(id, options) {
-  const effectMap = /* @__PURE__ */ new WeakMap();
-  const subscribeMap = /* @__PURE__ */ new WeakMap();
-  const cleanUpMap = /* @__PURE__ */ new WeakMap();
-  function useStore(pinia) {
-    if (pinia) setActivePinia(pinia);
-    if (!activePinia) {
-      throw new Error(
-        `[\u{1F34D}]: "getActivePinia()" was called but there was no active Pinia. Are you trying to use a store before calling "createPinia()"?
-`
-      );
+    if (activeListenerId && activeGetterKey && activeListenerId !== id) {
+      const accessedStoreScope = pinia._scopes.get(id);
+      if (accessedStoreScope) {
+        let subscribers = accessedStoreScope.subscribers.get(activeListenerId);
+        if (!subscribers) {
+          subscribers = /* @__PURE__ */ new Set();
+          accessedStoreScope.subscribers.set(activeListenerId, subscribers);
+        }
+        subscribers.add(activeGetterKey);
+      }
     }
-    pinia = activePinia;
-    const lastEffect = activeEffect.value;
-    activeEffect.value = void 0;
-    if (!pinia._s.has(id)) createOptionsStore(id, options, pinia);
-    activeEffect.value = lastEffect;
-    const store = pinia._s.get(id);
-    const _id = useRef([useId()]);
-    const storeSnapshotRef = useRef({ ...store });
-    const isCollectDep = useRef(false);
-    if (!cleanUpMap.get(_id.current)) {
-      cleanUpMap.set(_id.current, []);
+    return pinia._s.get(id);
+  }
+  function useStore() {
+    const pinia = getActivePinia();
+    if (!pinia._s.has(id)) {
+      createStoreInstance();
     }
-    activeComponentCleanUp[0] = cleanUpMap.get(_id.current);
-    useEffect(() => {
-      activeComponentCleanUp[0] = cleanUpMap.get(_id.current);
-      return () => {
-        cleanUpMap.get(_id.current).forEach((fn) => {
-          fn();
-        });
-      };
-    }, []);
-    const subscribe = useCallback((onStoreChange) => {
-      subscribeMap.set(_id.current, onStoreChange);
-      return () => {
-        const effect2 = effectMap.get(_id.current);
-        if (effect2) effect2.stop();
-        subscribeMap.delete(_id.current);
-        effectMap.delete(_id.current);
-      };
-    }, []);
-    useSyncExternalStore(
-      subscribe,
-      () => storeSnapshotRef.current,
-      () => storeSnapshotRef.current
+    const currentScope = pinia._scopes.get(id);
+    const trackedPaths = useRef(/* @__PURE__ */ new Set());
+    trackedPaths.current.clear();
+    const subscribe = useCallback(
+      (onStoreChange) => {
+        const listener = (_state, _prevState, patches) => {
+          let shouldUpdate = false;
+          for (const path of trackedPaths.current) {
+            const topKey = path.split(".")[0];
+            if (topKey in getters) {
+              if (!currentScope.getterCache.has(topKey)) {
+                shouldUpdate = true;
+                break;
+              }
+            } else {
+              if (patches.length > 0 && isAffected(patches, /* @__PURE__ */ new Set([path]))) {
+                shouldUpdate = true;
+                break;
+              }
+            }
+          }
+          if (shouldUpdate) {
+            onStoreChange();
+          }
+        };
+        currentScope.listeners.add(listener);
+        return () => currentScope.listeners.delete(listener);
+      },
+      [currentScope]
     );
-    let effect = effectMap.get(_id.current);
-    if (!effect) {
-      const fn = () => {
-        const onStoreChange = subscribeMap.get(_id.current);
-        if (!isCollectDep.current) {
-          storeSnapshotRef.current = { ...store };
-          onStoreChange?.();
-        }
-      };
-      effect = new ReactiveEffect(fn, noop2, () => {
-        if (effect?.dirty) effect.run();
-      });
-      activeEffect.value = effect;
-      isCollectDep.current = true;
-      effect.run();
-      effectMap.set(_id.current, effect);
-      isCollectDep.current = false;
-    }
-    return store;
+    const getSnapshot = useCallback(() => currentScope.currentState, [currentScope]);
+    useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    const trackingProxy = currentScope.createStoreProxy((path) => {
+      trackedPaths.current.add(path.join("."));
+    });
+    return trackingProxy;
   }
-  useStore.$id = id;
-  useStore.$getStore = (pinia) => {
-    if (pinia) setActivePinia(pinia);
-    pinia = activePinia;
-    if (!pinia._s.has(id)) createOptionsStore(id, options, pinia);
-    const store = pinia._s.get(id);
-    return store;
-  };
-  return useStore;
+  return { useStore, getStore };
 }
 export {
-  MutationType,
   createPinia,
   defineStore,
   getActivePinia,