pinia-react 2.1.1 → 2.1.3

package/dist/index.d.cts

@@ -0,0 +1,106 @@
+import { Draft, Patch } from 'immer';
+
+type StateTree = Record<string, any>;
+type StatePath = string[];
+type MutationType = 'action' | 'patch' | 'reset' | 'restore';
+/** Metadata describing why a state transition was committed. */
+interface MutationMeta {
+    type: MutationType;
+    origin?: string;
+    action?: string;
+    args?: unknown[];
+}
+/** A committed state transition, intended for Pinia plugins. */
+interface MutationEvent<S extends StateTree = StateTree> {
+    storeId: string;
+    store: StoreGeneric;
+    state: S;
+    prevState: S;
+    patches: Patch[];
+    meta: MutationMeta;
+}
+type MutationListener = (event: MutationEvent) => void;
+interface RestoreStateOptions {
+    type?: Extract<MutationType, 'restore' | 'reset'>;
+    origin?: string;
+}
+type TransformGetters<G> = {
+    [K in keyof G]: G[K] extends (...args: any[]) => infer R ? R : never;
+};
+type TransformActions<A> = A;
+type SubscriptionCallback<S> = (state: S, prevState: S) => void;
+type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? ReadonlyArray<DeepReadonly<U>> : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+interface PiniaCustomProperties<Id extends string = string, S extends StateTree = StateTree, G extends Record<string, any> = Record<string, any>, A extends Record<string, any> = Record<string, any>> {
+}
+interface StorePublicApi<Id extends string = string, S = StateTree> {
+    readonly $id: Id;
+    $patch: (updater: (draft: Draft<S>) => void) => void;
+    $reset: () => void;
+    $subscribe: (callback: SubscriptionCallback<S>) => () => void;
+    $state: DeepReadonly<S>;
+}
+type GetterContext<S, G> = Readonly<S> & TransformGetters<G>;
+type ActionContext<S, G, A> = S & TransformGetters<G> & TransformActions<A> & StorePublicApi<string, S>;
+type Store<Id extends string, S extends StateTree, G extends Record<string, any>, A extends Record<string, any>> = S & TransformGetters<G> & TransformActions<A> & StorePublicApi<Id, S> & PiniaCustomProperties<Id, S, G, A>;
+type StoreGeneric = Store<string, StateTree, Record<string, any>, Record<string, any>>;
+type GettersImplementation<S> = {
+    [K in string]: (state: S) => any;
+};
+/** Extension point for store-option plugins. */
+interface DefineStoreOptionsBase<S extends StateTree, Store> {
+}
+interface DefineStoreOptions<S extends StateTree, G extends Record<string, any>, A extends Record<string, any>> extends DefineStoreOptionsBase<S, Store<string, S, G, A>> {
+    state: () => S;
+    getters?: G & ThisType<GetterContext<S, G>> & GettersImplementation<S>;
+    actions?: A & ThisType<ActionContext<S, G, A>>;
+}
+type StoreScope = {
+    currentState: StateTree;
+    listeners: Set<(state: any, prev: any, patches: Patch[]) => void>;
+    getterResultCache: Map<string, any>;
+    getterDependencies: Map<string, Set<StatePath>>;
+    subscribers: Map<string, Set<string>>;
+    createStoreProxy: (onAccess?: (path: StatePath) => void) => StoreGeneric;
+};
+interface Pinia {
+    state: Record<string, StateTree>;
+    use(plugin: PiniaPlugin): Pinia;
+    /** Subscribe to committed mutations from every store in this Pinia instance. */
+    onMutation(listener: MutationListener): () => void;
+    _p: PiniaPlugin[];
+    _s: Map<string, StoreGeneric>;
+    _scopes: Map<string, StoreScope>;
+    _m: Set<MutationListener>;
+}
+interface PiniaPlugin {
+    (context: PiniaPluginContext): Partial<PiniaCustomProperties> | void;
+}
+type PiniaPluginContext<Id extends string = string, S extends StateTree = StateTree, G extends Record<string, any> = Record<string, any>, A extends Record<string, any> = Record<string, any>> = {
+    id: Id;
+    store: Store<Id, S, G, A>;
+    options: DefineStoreOptions<S, G, A>;
+    pinia: Pinia;
+    /** A plugin-only, fully controlled state replacement operation. */
+    restoreState: (state: S, options?: RestoreStateOptions) => void;
+};
+interface StoreDefinition<Id extends string, S extends StateTree, G extends Record<string, any>, A extends Record<string, any>> {
+    useStore: () => Store<Id, S, G, A>;
+    getStore: () => Store<Id, S, G, A>;
+}
+type NamedStoreDefinition<Id extends string, S extends StateTree, G extends Record<string, any>, A extends Record<string, any>> = string extends Id ? {} : {
+    [K in `use${Capitalize<Id>}Store`]: () => Store<Id, S, G, A>;
+} & {
+    [K in `get${Capitalize<Id>}Store`]: () => Store<Id, S, G, A>;
+};
+type StoreDefinitionWithNames<Id extends string, S extends StateTree, G extends Record<string, any>, A extends Record<string, any>> = StoreDefinition<Id, S, G, A> & NamedStoreDefinition<Id, S, G, A>;
+
+declare function createPinia(): Pinia;
+
+declare function setActivePinia(pinia: Pinia): void;
+declare function getActivePinia(): Pinia;
+
+declare function defineStore<Id extends string, S extends StateTree, G extends Record<string, any> = {}, A extends Record<string, any> = {}>(id: Id, options: DefineStoreOptions<S, G, A>): StoreDefinitionWithNames<Id, S, G, A>;
+
+export { type DeepReadonly, type DefineStoreOptions, type DefineStoreOptionsBase, type MutationEvent, type MutationListener, type MutationMeta, type MutationType, type Pinia, type PiniaCustomProperties, type PiniaPlugin, type PiniaPluginContext, type RestoreStateOptions, type StatePath, type StateTree, type Store, type StoreDefinition, type StoreGeneric, type SubscriptionCallback, createPinia, defineStore, getActivePinia, setActivePinia };

package/dist/index.d.ts

@@ -1,27 +1,57 @@
 import { Draft, Patch } from 'immer';
 
 type StateTree = Record<string, any>;
+type StatePath = string[];
+type MutationType = 'action' | 'patch' | 'reset' | 'restore';
+/** Metadata describing why a state transition was committed. */
+interface MutationMeta {
+    type: MutationType;
+    origin?: string;
+    action?: string;
+    args?: unknown[];
+}
+/** A committed state transition, intended for Pinia plugins. */
+interface MutationEvent<S extends StateTree = StateTree> {
+    storeId: string;
+    store: StoreGeneric;
+    state: S;
+    prevState: S;
+    patches: Patch[];
+    meta: MutationMeta;
+}
+type MutationListener = (event: MutationEvent) => void;
+interface RestoreStateOptions {
+    type?: Extract<MutationType, 'restore' | 'reset'>;
+    origin?: string;
+}
 type TransformGetters<G> = {
     [K in keyof G]: G[K] extends (...args: any[]) => infer R ? R : never;
 };
 type TransformActions<A> = A;
 type SubscriptionCallback<S> = (state: S, prevState: S) => void;
+type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? ReadonlyArray<DeepReadonly<U>> : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
 interface PiniaCustomProperties<Id extends string = string, S extends StateTree = StateTree, G extends Record<string, any> = Record<string, any>, A extends Record<string, any> = Record<string, any>> {
 }
-interface StorePublicApi<S> {
+interface StorePublicApi<Id extends string = string, S = StateTree> {
+    readonly $id: Id;
     $patch: (updater: (draft: Draft<S>) => void) => void;
     $reset: () => void;
     $subscribe: (callback: SubscriptionCallback<S>) => () => void;
-    $state: S;
+    $state: DeepReadonly<S>;
 }
 type GetterContext<S, G> = Readonly<S> & TransformGetters<G>;
-type ActionContext<S, G, A> = S & TransformGetters<G> & TransformActions<A> & StorePublicApi<S>;
-type Store<Id extends string, S extends StateTree, G extends Record<string, any>, A extends Record<string, any>> = S & TransformGetters<G> & TransformActions<A> & StorePublicApi<S> & PiniaCustomProperties<Id, S, G, A>;
+type ActionContext<S, G, A> = S & TransformGetters<G> & TransformActions<A> & StorePublicApi<string, S>;
+type Store<Id extends string, S extends StateTree, G extends Record<string, any>, A extends Record<string, any>> = S & TransformGetters<G> & TransformActions<A> & StorePublicApi<Id, S> & PiniaCustomProperties<Id, S, G, A>;
 type StoreGeneric = Store<string, StateTree, Record<string, any>, Record<string, any>>;
 type GettersImplementation<S> = {
     [K in string]: (state: S) => any;
 };
-interface DefineStoreOptions<S extends StateTree, G extends Record<string, any>, A extends Record<string, any>> {
+/** Extension point for store-option plugins. */
+interface DefineStoreOptionsBase<S extends StateTree, Store> {
+}
+interface DefineStoreOptions<S extends StateTree, G extends Record<string, any>, A extends Record<string, any>> extends DefineStoreOptionsBase<S, Store<string, S, G, A>> {
     state: () => S;
     getters?: G & ThisType<GetterContext<S, G>> & GettersImplementation<S>;
     actions?: A & ThisType<ActionContext<S, G, A>>;
@@ -30,16 +60,19 @@ type StoreScope = {
     currentState: StateTree;
     listeners: Set<(state: any, prev: any, patches: Patch[]) => void>;
     getterResultCache: Map<string, any>;
-    getterDependencies: Map<string, Set<string>>;
+    getterDependencies: Map<string, Set<StatePath>>;
     subscribers: Map<string, Set<string>>;
-    createStoreProxy: (onAccess?: (path: string[]) => void) => StoreGeneric;
+    createStoreProxy: (onAccess?: (path: StatePath) => void) => StoreGeneric;
 };
 interface Pinia {
     state: Record<string, StateTree>;
     use(plugin: PiniaPlugin): Pinia;
+    /** Subscribe to committed mutations from every store in this Pinia instance. */
+    onMutation(listener: MutationListener): () => void;
     _p: PiniaPlugin[];
     _s: Map<string, StoreGeneric>;
     _scopes: Map<string, StoreScope>;
+    _m: Set<MutationListener>;
 }
 interface PiniaPlugin {
     (context: PiniaPluginContext): Partial<PiniaCustomProperties> | void;
@@ -48,6 +81,9 @@ type PiniaPluginContext<Id extends string = string, S extends StateTree = StateT
     id: Id;
     store: Store<Id, S, G, A>;
     options: DefineStoreOptions<S, G, A>;
+    pinia: Pinia;
+    /** A plugin-only, fully controlled state replacement operation. */
+    restoreState: (state: S, options?: RestoreStateOptions) => void;
 };
 interface StoreDefinition<Id extends string, S extends StateTree, G extends Record<string, any>, A extends Record<string, any>> {
     useStore: () => Store<Id, S, G, A>;
@@ -67,4 +103,4 @@ declare function getActivePinia(): Pinia;
 
 declare function defineStore<Id extends string, S extends StateTree, G extends Record<string, any> = {}, A extends Record<string, any> = {}>(id: Id, options: DefineStoreOptions<S, G, A>): StoreDefinitionWithNames<Id, S, G, A>;
 
-export { type DefineStoreOptions, type Pinia, type PiniaCustomProperties, type PiniaPlugin, type PiniaPluginContext, type StateTree, type Store, type StoreDefinition, type StoreGeneric, type SubscriptionCallback, createPinia, defineStore, getActivePinia, setActivePinia };
+export { type DeepReadonly, type DefineStoreOptions, type DefineStoreOptionsBase, type MutationEvent, type MutationListener, type MutationMeta, type MutationType, type Pinia, type PiniaCustomProperties, type PiniaPlugin, type PiniaPluginContext, type RestoreStateOptions, type StatePath, type StateTree, type Store, type StoreDefinition, type StoreGeneric, type SubscriptionCallback, createPinia, defineStore, getActivePinia, setActivePinia };

package/dist/index.js

@@ -18,14 +18,25 @@ function createPinia() {
   const _p = [];
   const _s = /* @__PURE__ */ new Map();
   const _scopes = /* @__PURE__ */ new Map();
+  const _m = /* @__PURE__ */ new Set();
   const pinia = {
     use(plugin) {
+      if (_s.size > 0) {
+        console.warn(
+          "[pinia-react] A plugin was registered after stores were created. The new plugin will not be applied to the stores that already exist."
+        );
+      }
       _p.push(plugin);
       return this;
     },
+    onMutation(listener) {
+      _m.add(listener);
+      return () => _m.delete(listener);
+    },
     _p,
     _s,
     _scopes,
+    _m,
     state
   };
   setActivePinia(pinia);
@@ -33,15 +44,16 @@ function createPinia() {
 }
 
 // src/store.ts
-import { enablePatches, produce, setAutoFreeze } from "immer";
+import { enablePatches, Immer } from "immer";
 import { useCallback, useRef, useSyncExternalStore } from "react";
 enablePatches();
-setAutoFreeze(false);
+var immer = new Immer({ autoFreeze: false });
 var activeListenerId = null;
 var activeGetterKey = null;
+var storeDefinitionByPinia = /* @__PURE__ */ new WeakMap();
 function isAffected(patches, trackedPaths) {
   if (trackedPaths.size === 0) return false;
-  const tracked = Array.from(trackedPaths).map((p) => p.split("."));
+  const tracked = Array.from(trackedPaths);
   for (const patch of patches) {
     const patchPath = patch.path.map(String);
     for (const trackedPath of tracked) {
@@ -58,8 +70,23 @@ function isAffected(patches, trackedPaths) {
   }
   return false;
 }
+function isPlainObjectOrArray(value) {
+  if (Array.isArray(value)) return true;
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
 function defineStore(id, options) {
   const getters = options.getters || {};
+  function ensureStoreInstance(pinia) {
+    if (pinia._s.has(id)) {
+      if (storeDefinitionByPinia.get(pinia)?.get(id) === options) return;
+      console.warn(
+        `[pinia-react] Duplicate store id "${id}" detected. The new definition replaces the previous store with the same id.`
+      );
+    }
+    createStoreInstance();
+  }
   function resolveGetterDependencies(getterName, getterDepsMap, visited = /* @__PURE__ */ new Set()) {
     if (visited.has(getterName)) {
       console.warn(`[pinia-react] Circular dependency in getters detected involving: ${getterName}`);
@@ -70,8 +97,9 @@ function defineStore(id, options) {
     const directDeps = getterDepsMap.get(getterName);
     if (!directDeps) return finalDeps;
     for (const dep of directDeps) {
-      if (dep in getters) {
-        const nestedDeps = resolveGetterDependencies(dep, getterDepsMap, visited);
+      const getterKey = dep.length === 1 ? dep[0] : void 0;
+      if (getterKey && getterKey in getters) {
+        const nestedDeps = resolveGetterDependencies(getterKey, getterDepsMap, visited);
         nestedDeps.forEach((d) => finalDeps.add(d));
       } else {
         finalDeps.add(dep);
@@ -83,8 +111,6 @@ function defineStore(id, options) {
     const pinia = getActivePinia();
     const initialState = options.state();
     let storePublicApi;
-    let devTools;
-    let isTimeTraveling = false;
     const localScope = {
       currentState: initialState,
       listeners: /* @__PURE__ */ new Set(),
@@ -94,6 +120,12 @@ function defineStore(id, options) {
       createStoreProxy: (_onAccess) => storePublicApi
     };
     pinia._scopes.set(id, localScope);
+    let definitionsById = storeDefinitionByPinia.get(pinia);
+    if (!definitionsById) {
+      definitionsById = /* @__PURE__ */ new Map();
+      storeDefinitionByPinia.set(pinia, definitionsById);
+    }
+    definitionsById.set(id, options);
     const isGetterComputing = /* @__PURE__ */ new Set();
     const emit = (nextState, oldState, patches) => {
       localScope.listeners.forEach((fn) => fn(nextState, oldState, patches));
@@ -116,28 +148,42 @@ function defineStore(id, options) {
         }
       });
     };
-    const internalPatch = (updater, actionName, isReset = false) => {
-      if (isTimeTraveling) return;
+    const internalPatch = (updater, meta) => {
       const oldState = localScope.currentState;
       let patches = [];
-      const nextState = produce(oldState, updater, (p) => {
+      const nextState = immer.produce(oldState, updater, (p) => {
         patches = p;
       });
-      if (patches.length > 0 || isReset) {
+      if (patches.length > 0 || meta.type === "reset") {
         localScope.currentState = nextState;
         pinia.state[id] = nextState;
-        if (devTools) {
-          devTools.send({ type: actionName, payload: patches }, nextState);
-        }
         emit(nextState, oldState, patches);
+        const event = {
+          storeId: id,
+          store: storePublicApi,
+          state: nextState,
+          prevState: oldState,
+          patches,
+          meta
+        };
+        pinia._m.forEach((listener) => listener(event));
       }
     };
     const $patch = (updater) => {
-      internalPatch((draft) => {
-        updater(draft);
-      }, "@patch");
+      internalPatch(
+        (draft) => {
+          updater(draft);
+        },
+        { type: "patch" }
+      );
+    };
+    const $reset = () => internalPatch(() => options.state(), { type: "reset" });
+    const restoreState = (state, options2 = {}) => {
+      internalPatch(() => state, {
+        type: options2.type ?? "restore",
+        origin: options2.origin
+      });
     };
-    const $reset = () => internalPatch(() => options.state(), "@reset", true);
     const $subscribe = (callback) => {
       const listener = (state, prev) => callback(state, prev);
       localScope.listeners.add(listener);
@@ -155,37 +201,92 @@ function defineStore(id, options) {
     const originalActions = options.actions || {};
     const wrappedActions = {};
     const proxyTarget = {};
+    const readonlyStateProxyCache = /* @__PURE__ */ new WeakMap();
+    const readonlyWarning = () => {
+      console.warn(`[${id}] Store is read-only. Use actions for mutations.`);
+      throw new TypeError(`[${id}] Store is read-only. Use actions for mutations.`);
+    };
+    const createReadonlyStateProxy = (stateTarget) => {
+      const cached = readonlyStateProxyCache.get(stateTarget);
+      if (cached) return cached;
+      const proxy = new Proxy(stateTarget, {
+        get(obj, key) {
+          const value = Reflect.get(obj, key);
+          if (isPlainObjectOrArray(value)) return createReadonlyStateProxy(value);
+          return value;
+        },
+        set: readonlyWarning,
+        deleteProperty: readonlyWarning
+      });
+      readonlyStateProxyCache.set(stateTarget, proxy);
+      return proxy;
+    };
+    const getAtPath = (path) => {
+      let value = localScope.currentState;
+      for (const key of path) value = value[key];
+      return value;
+    };
+    const setAtPath = (draft, path, value) => {
+      let target = draft;
+      for (let i = 0; i < path.length - 1; i++) target = target[path[i]];
+      target[path[path.length - 1]] = value;
+    };
+    const deleteAtPath = (draft, path) => {
+      let target = draft;
+      for (let i = 0; i < path.length - 1; i++) target = target[path[i]];
+      delete target[path[path.length - 1]];
+    };
+    const createActionStateProxy = (path, meta) => {
+      return new Proxy(Array.isArray(getAtPath(path)) ? [] : {}, {
+        get(_target, key, receiver) {
+          const current = getAtPath(path);
+          const value = Reflect.get(current, key, receiver);
+          if (typeof key === "symbol" || !isPlainObjectOrArray(value)) return value;
+          return createActionStateProxy([...path, String(key)], meta);
+        },
+        set(_target, key, value) {
+          internalPatch((draft) => setAtPath(draft, [...path, String(key)], value), meta);
+          return true;
+        },
+        deleteProperty(_target, key) {
+          internalPatch((draft) => deleteAtPath(draft, [...path, String(key)]), meta);
+          return true;
+        }
+      });
+    };
     function createStoreProxy(onAccess) {
-      const readonlyWarning = () => {
-        console.warn(`[${id}] Store is read-only. Use actions for mutations.`);
-        return false;
-      };
-      const createStateProxy = (stateTarget, path, onDeepAccess) => {
+      const createStateProxy = (stateTarget, path, onDeepAccess, trackObjectAccess = false) => {
         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);
+            if (isPlainObjectOrArray(value)) {
+              if (trackObjectAccess) onDeepAccess?.(currentPath);
+              return createStateProxy(value, currentPath, onDeepAccess, trackObjectAccess);
             }
             onDeepAccess?.(currentPath);
             return value;
           },
-          set: readonlyWarning
+          set: readonlyWarning,
+          deleteProperty: readonlyWarning
         });
       };
       return new Proxy(proxyTarget, {
         get(_target, key, receiver) {
           const strKey = String(key);
-          if (strKey === "$state") return localScope.currentState;
+          if (strKey === "$state") {
+            onAccess?.(["$state"]);
+            return createReadonlyStateProxy(localScope.currentState);
+          }
+          if (strKey === "$id") return id;
           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) {
+            if (isPlainObjectOrArray(value)) {
               return createStateProxy(value, [strKey], onAccess);
             }
             onAccess?.([strKey]);
@@ -206,10 +307,10 @@ function defineStore(id, options) {
             activeGetterKey = strKey;
             try {
               const onGetterAccess = (path) => {
-                dependencies.add(path[0]);
+                dependencies.add(path);
               };
               const trackingProxyForThis = createStoreProxy(onGetterAccess);
-              const trackingStateProxy = createStateProxy(state, [], onGetterAccess);
+              const trackingStateProxy = createStateProxy(state, [], onGetterAccess, true);
               const result = getters[strKey].call(trackingProxyForThis, trackingStateProxy);
               localScope.getterDependencies.set(strKey, dependencies);
               localScope.getterResultCache.set(strKey, result);
@@ -231,6 +332,7 @@ function defineStore(id, options) {
             console.warn(`[${id}] Do not replace "$state" directly. Use "$patch()" to replace the whole state.`);
             return false;
           }
+          if (strKey === "$id") return readonlyWarning();
           if (strKey in localScope.currentState || strKey in getters || strKey in wrappedActions) {
             return readonlyWarning();
           }
@@ -243,92 +345,63 @@ function defineStore(id, options) {
       const originalAction = originalActions[actionName];
       wrappedActions[actionName] = (...args) => {
         let returnValue;
+        let draftActive = true;
+        const meta = { type: "action", action: actionName, args };
         const recipe = (draft) => {
           const actionContextProxy = new Proxy({}, {
             get(_, key) {
               const strKey = String(key);
-              if (Reflect.has(draft, strKey)) return draft[strKey];
+              if (draftActive && Reflect.has(draft, strKey)) return draft[strKey];
+              if (!draftActive && Reflect.has(localScope.currentState, strKey)) {
+                const value = localScope.currentState[strKey];
+                if (value !== null && typeof value === "object") return createActionStateProxy([strKey], meta);
+                return value;
+              }
               if (strKey in getters) {
-                return getters[strKey].call(actionContextProxy, draft);
+                if (draftActive) return getters[strKey].call(actionContextProxy, draft);
+                return Reflect.get(storePublicApi, key, storePublicApi);
               }
               return Reflect.get(storePublicApi, key, storePublicApi);
             },
             set(_, key, value) {
-              ;
-              draft[String(key)] = value;
+              const path = [String(key)];
+              if (draftActive) draft[path[0]] = value;
+              else internalPatch((currentDraft) => setAtPath(currentDraft, path, value), meta);
+              return true;
+            },
+            deleteProperty(_, key) {
+              const path = [String(key)];
+              if (draftActive) delete draft[path[0]];
+              else internalPatch((currentDraft) => deleteAtPath(currentDraft, path), meta);
               return true;
             }
           });
           returnValue = originalAction.apply(actionContextProxy, args);
         };
-        internalPatch(recipe, actionName);
+        internalPatch(recipe, meta);
+        draftActive = false;
         return returnValue;
       };
     });
     localScope.createStoreProxy = createStoreProxy;
     pinia._p.forEach((plugin) => {
-      const pluginResult = plugin({ id, store: storePublicApi, options });
+      const pluginResult = plugin({
+        id,
+        store: storePublicApi,
+        options,
+        pinia,
+        restoreState
+      });
       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.getterResultCache.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.getterResultCache.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;
   }
   function getStore() {
     const pinia = getActivePinia();
-    if (!pinia._s.has(id)) {
-      createStoreInstance();
-    }
+    ensureStoreInstance(pinia);
     if (activeListenerId && activeGetterKey && activeListenerId !== id) {
       const accessedStoreScope = pinia._scopes.get(id);
       if (accessedStoreScope) {
@@ -344,9 +417,7 @@ function defineStore(id, options) {
   }
   function useStore() {
     const pinia = getActivePinia();
-    if (!pinia._s.has(id)) {
-      createStoreInstance();
-    }
+    ensureStoreInstance(pinia);
     const currentScope = pinia._scopes.get(id);
     const trackedPaths = useRef(/* @__PURE__ */ new Set());
     trackedPaths.current.clear();
@@ -355,8 +426,12 @@ function defineStore(id, options) {
         const listener = (_state, _prevState, patches) => {
           let shouldUpdate = false;
           for (const path of trackedPaths.current) {
-            const topKey = path.split(".")[0];
-            if (topKey in getters) {
+            if (path.length === 1 && path[0] === "$state") {
+              shouldUpdate = patches.length > 0;
+              if (shouldUpdate) break;
+            }
+            const topKey = path[0];
+            if (path.length === 1 && topKey in getters) {
               if (!currentScope.getterResultCache.has(topKey)) {
                 shouldUpdate = true;
                 break;
@@ -380,7 +455,7 @@ function defineStore(id, options) {
     const getSnapshot = useCallback(() => currentScope.currentState, [currentScope]);
     useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
     const trackingProxy = currentScope.createStoreProxy((path) => {
-      trackedPaths.current.add(path.join("."));
+      trackedPaths.current.add(path);
     });
     return trackingProxy;
   }