pinia-react 1.2.1 → 1.3.1

package/LICENSE

@@ -1,6 +1,7 @@
-MIT License
+The MIT License (MIT)
 
 Copyright (c) 2025 karl
+Copyright (c) 2019-present Eduardo San Martin Morote
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,5 +1,167 @@
-# pinia-react
 
-它是什么东西？它是适用于 react 框架的 pinia。
+# React Pinia
 
-没错！我又造了新轮子，react 的状态管理器派系众多，但是为什么会有这个 react 版的 pinia ？因为我不允许 pinia 这么好的东西只能局限于 vue 框架使用。
+Pinia-react is a state management library for React inspired by Vue's Pinia, bringing a clean, reactive, and TypeScript-friendly state management experience.
+
+[](https://www.npmjs.com/package/pinia-react)
+[](https://github.com/your-username/pinia-react/blob/main/LICENSE)
+
+## Motivation
+
+The React ecosystem has a variety of state management tools, but they can often be overly complex or lack structure. Inspired by Pinia's modular design and elegant API, pinia-react combines React Hooks with the Pinia philosophy to provide a lightweight, intuitive, and TypeScript-friendly state management solution suitable for modern React applications.
+
+## Features
+
+  - 🔄 **Powerful Reactivity** - Based on the Vue 3 reactivity system, it automatically tracks dependencies and efficiently updates components.
+  - ⚡️ **Reactive** - Built on `useSyncExternalStore`, it perfectly adapts to React rendering.
+  - 🛠 **Modular** - Independent stores that support dynamic loading.
+  - 🔍 **TypeScript Friendly** - Automatic type inference with zero configuration.
+  - 🧩 **Plugin System** - Flexible extensions for features like persistence and logging.
+  - 🔀 **Familiar API** - The API design is fully inspired by Pinia, making it friendly for Vue developers.
+
+## Installation
+
+```bash
+pnpm add pinia-react
+```
+
+## Basic Usage
+
+### Creating and Using a Store
+
+```tsx
+import { defineStore } from 'pinia-react'
+import { useEffect } from 'react'
+
+// Define a store (API is identical to Pinia)
+const useCounterStore = defineStore('counter', {
+  // Define the initial state
+  state: () => ({
+    count: 0,
+    name: 'Counter'
+  }),
+  
+  // Define getter methods (similar to computed properties)
+  getters: {
+    doubleCount() {
+      return this.count * 2
+    }
+  },
+  
+  // Define action methods
+  actions: {
+    increment() {
+      this.count++
+    },
+    
+    async fetchSomething() {
+      // Supports asynchronous operations
+      const result = await api.get('/data')
+      this.count = result.count
+    }
+  }
+})
+
+// Use in a component
+function Counter() {
+  // Get the store instance
+  const store = useCounterStore()
+  
+  useEffect(() => {
+    // You can call an action method
+    store.fetchSomething()
+  }, [])
+  
+  return (
+    <div>
+      <h1>{store.name}: {store.count}</h1>
+      <p>Double count: {store.doubleCount}</p>
+      <button onClick={() => store.increment()}>Increment</button>
+    </div>
+  )
+}
+```
+
+### Interacting Between Multiple Stores
+
+```tsx
+import { defineStore } from 'pinia-react'
+
+// User Store
+const useUserStore = defineStore('user', {
+  state: () => ({
+    name: 'Anonymous',
+    isAdmin: false
+  }),
+  actions: {
+    login(name, admin = false) {
+      this.name = name
+      this.isAdmin = admin
+    },
+    logout() {
+      this.name = 'Anonymous'
+      this.isAdmin = false
+    }
+  }
+})
+
+// Cart Store, which depends on the User Store
+const useCartStore = defineStore('cart', {
+  state: () => ({
+    items: []
+  }),
+  getters: {
+    isEmpty() {
+      return this.items.length === 0
+    },
+    // Can use other stores
+    isCheckoutAllowed() {
+      const userStore = useUserStore.$getStore()
+      return this.items.length > 0 && userStore.name !== 'Anonymous'
+    }
+  },
+  actions: {
+    addItem(item) {
+      this.items.push(item)
+    },
+    checkout() {
+      const userStore = useUserStore.$getStore()
+      if (userStore.name === 'Anonymous') {
+        throw new Error('Login required')
+      }
+      // Handle checkout logic...
+      this.items = []
+    }
+  }
+})
+```
+
+### Plugin System
+
+Pinia-react supports extending functionality through plugins.
+
+```ts
+import { createpinia } from 'pinia-react'
+
+// Create a pinia instance
+const pinia = createpinia()
+
+// Use a plugin
+pinia.use(myPlugin)
+
+
+// Plugin example
+function myPlugin({ store, options }) {
+  // Add custom properties or methods to the store
+  return {
+    customProperty: 'value',
+    customMethod() {
+      // Custom logic
+    }
+  }
+}
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -1,41 +1,334 @@
+import { ComputedRef, DebuggerEvent, EffectScope, Ref, UnwrapRef, WatchOptions, WritableComputedRef } from "@maoism/runtime-core";
+
 //#region src/types.d.ts
 
-type StateTree = Record<string | number | symbol, unknown>;
-type _StoreWithGetters<G> = { readonly [k in keyof G]: G[k] extends ((...args: any[]) => infer R) ? R : G[k] };
-type _ActionsTree = Record<string | number | symbol, (...args: any[]) => any>;
-type PiniaCustomStateProperties<S extends StateTree = StateTree> = {};
-type _GettersTree<S extends StateTree> = Record<string, (state: S & PiniaCustomStateProperties<S>) => any>;
 /**
- * Interface to be extended by the user when they add properties through plugins.
+ * Generic state of a Store
+ */
+type StateTree = Record<PropertyKey, any>;
+/**
+ * Recursive `Partial<T>`. Used by {@link Store['$patch']}.
+ *
+ * For internal use **only**
  */
-type PiniaCustomProperties<Id extends string = string, S extends StateTree = StateTree, G = _GettersTree<S>, A = _ActionsTree> = {};
 type _DeepPartial<T> = { [K in keyof T]?: _DeepPartial<T[K]> };
-interface _StoreWithState<Id extends string, S extends StateTree, G, A> {
+/**
+ * Possible types for SubscriptionCallback
+ */
+declare enum MutationType {
+  /**
+   * Direct mutation of the state:
+   *
+   * - `store.name = 'new name'`
+   * - `store.$state.name = 'new name'`
+   * - `store.list.push('new item')`
+   */
+  direct = "direct",
+  /**
+   * Mutated the state with `$patch` and an object
+   *
+   * - `store.$patch({ name: 'newName' })`
+   */
+  patchObject = "patch object",
+  /**
+   * Mutated the state with `$patch` and a function
+   *
+   * - `store.$patch(state => state.name = 'newName')`
+   */
+  patchFunction = "patch function",
+}
+/**
+ * Base type for the context passed to a subscription callback. Internal type.
+ */
+interface _SubscriptionCallbackMutationBase {
+  /**
+   * Type of the mutation.
+   */
+  type: MutationType;
+  /**
+   * `id` of the store doing the mutation.
+   */
+  storeId: string;
+  /**
+   * 🔴 DEV ONLY, DO NOT use for production code. Different mutation calls. Comes from
+   * https://vuejs.org/guide/extras/reactivity-in-depth.html#reactivity-debugging and allows to track mutations in
+   * devtools and plugins **during development only**.
+   */
+  events?: DebuggerEvent[] | DebuggerEvent;
+}
+/**
+ * Context passed to a subscription callback when directly mutating the state of
+ * a store with `store.someState = newValue` or `store.$state.someState =
+ * newValue`.
+ */
+interface SubscriptionCallbackMutationDirect extends _SubscriptionCallbackMutationBase {
+  type: MutationType.direct;
+  events: DebuggerEvent;
+}
+/**
+ * Context passed to a subscription callback when `store.$patch()` is called
+ * with an object.
+ */
+interface SubscriptionCallbackMutationPatchObject<S> extends _SubscriptionCallbackMutationBase {
+  type: MutationType.patchObject;
+  events: DebuggerEvent[];
+  /**
+   * Object passed to `store.$patch()`.
+   */
+  payload: _DeepPartial<UnwrapRef<S>>;
+}
+/**
+ * Context passed to a subscription callback when `store.$patch()` is called
+ * with a function.
+ */
+interface SubscriptionCallbackMutationPatchFunction extends _SubscriptionCallbackMutationBase {
+  type: MutationType.patchFunction;
+  events: DebuggerEvent[];
+}
+/**
+ * Context object passed to a subscription callback.
+ */
+type SubscriptionCallbackMutation<S> = SubscriptionCallbackMutationDirect | SubscriptionCallbackMutationPatchObject<S> | SubscriptionCallbackMutationPatchFunction;
+/**
+ * Callback of a subscription
+ */
+type SubscriptionCallback<S> = (
+/**
+ * Object with information relative to the store mutation that triggered the
+ * subscription.
+ */
+mutation: SubscriptionCallbackMutation<S>,
+/**
+ * State of the store when the subscription is triggered. Same as
+ * `store.$state`.
+ */
+state: UnwrapRef<S>) => void;
+/**
+ * Actual type for {@link StoreOnActionListenerContext}. Exists for refactoring
+ * purposes. For internal use only.
+ * For internal use **only**
+ */
+interface _StoreOnActionListenerContext<Store, ActionName extends string, A> {
+  /**
+   * Name of the action
+   */
+  name: ActionName;
+  /**
+   * Store that is invoking the action
+   */
+  store: Store;
+  /**
+   * Parameters passed to the action
+   */
+  args: A extends Record<ActionName, _Method> ? Parameters<A[ActionName]> : unknown[];
+  /**
+   * Sets up a hook once the action is finished. It receives the return value
+   * of the action, if it's a Promise, it will be unwrapped.
+   */
+  after: (callback: A extends Record<ActionName, _Method> ? (resolvedReturn: Awaited<ReturnType<A[ActionName]>>) => void : () => void) => void;
+  /**
+   * Sets up a hook if the action fails. Return `false` to catch the error and
+   * stop it from propagating.
+   */
+  onError: (callback: (error: unknown) => void) => void;
+}
+/**
+ * Context object passed to callbacks of `store.$onAction(context => {})`
+ * TODO: should have only the Id, the Store and Actions to generate the proper object
+ */
+type StoreOnActionListenerContext<Id extends string, S extends StateTree, G, A> = _ActionsTree extends A ? _StoreOnActionListenerContext<StoreGeneric, string, _ActionsTree> : { [Name in keyof A]: Name extends string ? _StoreOnActionListenerContext<Store<Id, S, G, A>, Name, A> : never }[keyof A];
+/**
+ * Argument of `store.$onAction()`
+ */
+type StoreOnActionListener<Id extends string, S extends StateTree, G, A> = (context: StoreOnActionListenerContext<Id, S, G, {} extends A ? _ActionsTree : A>) => void;
+/**
+ * Properties of a store.
+ */
+interface StoreProperties<Id extends string> {
+  /**
+   * Unique identifier of the store
+   */
   $id: Id;
-  $state: S & PiniaCustomStateProperties<S>;
-  $patch(partialState: _DeepPartial<S>): void;
-  $patch<F extends (state: S) => any>(stateMutator: ReturnType<F> extends Promise<any> ? never : F): void;
+  /**
+   * Private property defining the pinia the store is attached to.
+   *
+   * @internal
+   */
+  _p: Pinia;
+  /**
+   * Used by devtools plugin to retrieve getters. Removed in production.
+   *
+   * @internal
+   */
+  _getters?: string[];
+  /**
+   * Used (and added) by devtools plugin to detect Setup vs Options API usage.
+   *
+   * @internal
+   */
+  _isOptionsAPI?: boolean;
+  /**
+   * Used by devtools plugin to retrieve properties added with plugins. Removed
+   * in production. Can be used by the user to add property keys of the store
+   * that should be displayed in devtools.
+   */
+  _customProperties: Set<string>;
+  /**
+   * Handles a HMR replacement of this store. Dev Only.
+   *
+   * @internal
+   */
+  _hotUpdate(useStore: StoreGeneric): void;
+  /**
+   * Allows pausing some of the watching mechanisms while the store is being
+   * patched with a newer version.
+   *
+   * @internal
+   */
+  _hotUpdating: boolean;
+  /**
+   * Payload of the hmr update. Dev only.
+   *
+   * @internal
+   */
+  _hmrPayload: {
+    state: string[];
+    hotState: Ref<StateTree>;
+    actions: _ActionsTree;
+    getters: _ActionsTree;
+  };
+}
+/**
+ * Base store with state and functions. Should not be used directly.
+ */
+interface _StoreWithState<Id extends string, S extends StateTree, G, A> extends StoreProperties<Id> {
+  /**
+   * State of the Store. Setting it will internally call `$patch()` to update the state.
+   */
+  $state: UnwrapRef<S> & PiniaCustomStateProperties<S>;
+  /**
+   * Applies a state patch to current state. Allows passing nested values
+   *
+   * @param partialState - patch to apply to the state
+   */
+  $patch(partialState: _DeepPartial<UnwrapRef<S>>): void;
+  /**
+   * Group multiple changes into one function. Useful when mutating objects like
+   * Sets or arrays and applying an object patch isn't practical, e.g. appending
+   * to an array. The function passed to `$patch()` **must be synchronous**.
+   *
+   * @param stateMutator - function that mutates `state`, cannot be asynchronous
+   */
+  $patch<F extends (state: UnwrapRef<S>) => any>(stateMutator: ReturnType<F> extends Promise<any> ? never : F): void;
+  /**
+   * Resets the store to its initial state by building a new state object.
+   */
   $reset(): void;
-  $subscribe(callback: (newValue: S) => any, options?: {
-    detached: boolean;
-  }): any;
+  /**
+   * Setups a callback to be called whenever the state changes. It also returns a function to remove the callback. Note
+   * that when calling `store.$subscribe()` inside of a component, it will be automatically cleaned up when the
+   * component gets unmounted unless `detached` is set to true.
+   *
+   * @param callback - callback passed to the watcher
+   * @param options - `watch` options + `detached` to detach the subscription from the context (usually a component)
+   * this is called from. Note that the `flush` option does not affect calls to `store.$patch()`.
+   * @returns function that removes the watcher
+   */
+  $subscribe(callback: SubscriptionCallback<S>, options?: {
+    detached?: boolean;
+  } & WatchOptions): () => void;
+  /**
+   * Setups a callback to be called every time an action is about to get
+   * invoked. The callback receives an object with all the relevant information
+   * of the invoked action:
+   * - `store`: the store it is invoked on
+   * - `name`: The name of the action
+   * - `args`: The parameters passed to the action
+   *
+   * On top of these, it receives two functions that allow setting up a callback
+   * once the action finishes or when it fails.
+   *
+   * It also returns a function to remove the callback. Note than when calling
+   * `store.$onAction()` inside of a component, it will be automatically cleaned
+   * up when the component gets unmounted unless `detached` is set to true.
+   *
+   * @example
+   *
+   *```js
+   *store.$onAction(({ after, onError }) => {
+   *  // Here you could share variables between all of the hooks as well as
+   *  // setting up watchers and clean them up
+   *  after((resolvedValue) => {
+   *    // can be used to cleanup side effects
+   * .  // `resolvedValue` is the value returned by the action, if it's a
+   * .  // Promise, it will be the resolved value instead of the Promise
+   *  })
+   *  onError((error) => {
+   *    // can be used to pass up errors
+   *  })
+   *})
+   *```
+   *
+   * @param callback - callback called before every action
+   * @param detached - detach the subscription from the context this is called from
+   * @returns function that removes the watcher
+   */
+  $onAction(callback: StoreOnActionListener<Id, S, G, A>, detached?: boolean): () => void;
+  /**
+   * Stops the associated effect scope of the store and remove it from the store
+   * registry. Plugins can override this method to cleanup any added effects.
+   * e.g. devtools plugin stops displaying disposed stores from devtools.
+   * Note this doesn't delete the state of the store, you have to do it manually with
+   * `delete pinia.state.value[store.$id]` if you want to. If you don't and the
+   * store is used again, it will reuse the previous state.
+   */
+  $dispose(): void;
 }
-type Store<Id extends string, S extends StateTree, G, A> = _StoreWithState<Id, S, G, A> & S & _StoreWithGetters<G> & (_ActionsTree extends A ? {} : A) & PiniaCustomProperties<Id, S, G, A> & PiniaCustomStateProperties<S>;
+/**
+ * Generic type for a function that can infer arguments and return type
+ *
+ * For internal use **only**
+ */
+type _Method = (...args: any[]) => any;
+/**
+ * Store augmented for actions. For internal usage only.
+ * For internal use **only**
+ */
+type _StoreWithActions<A> = { [k in keyof A]: A[k] extends ((...args: infer P) => infer R) ? (...args: P) => R : never };
+/**
+ * Store augmented with getters. For internal usage only.
+ * For internal use **only**
+ */
+type _StoreWithGetters<G> = _StoreWithGetters_Readonly<G> & _StoreWithGetters_Writable<G>;
+/**
+ * Store augmented with readonly getters. For internal usage **only**.
+ */
+type _StoreWithGetters_Readonly<G> = { readonly [K in keyof G as G[K] extends ((...args: any[]) => any) ? K : ComputedRef extends G[K] ? K : never]: G[K] extends ((...args: any[]) => infer R) ? R : UnwrapRef<G[K]> };
+/**
+ * Store augmented with writable getters. For internal usage **only**.
+ */
+type _StoreWithGetters_Writable<G> = { [K in keyof G as G[K] extends WritableComputedRef<any> ? K : never]: G[K] extends Readonly<WritableComputedRef<infer R>> ? R : never };
+/**
+ * Store type to build a store.
+ */
+type Store<Id extends string = string, S extends StateTree = {}, G = {}, A = {}> = _StoreWithState<Id, S, G, A> & UnwrapRef<S> & _StoreWithGetters<G> & (_ActionsTree extends A ? {} : A) & PiniaCustomProperties<Id, S, G, A> & PiniaCustomStateProperties<S>;
+/**
+ * Generic and type-unsafe version of Store. Doesn't fail on access with
+ * strings, making it much easier to write generic functions that do not care
+ * about the kind of store that is passed.
+ */
 type StoreGeneric = Store<string, StateTree, _GettersTree<StateTree>, _ActionsTree>;
-type DefineStoreOptionsBase<S extends StateTree, Store> = {};
-interface DefineStoreOptions<Id extends string, S extends StateTree, G, A> extends DefineStoreOptionsBase<S, Store<Id, S, G, A>> {
-  state?: () => S;
-  getters?: G & ThisType<S & _StoreWithGetters<G> & PiniaCustomProperties>;
-  actions?: A & ThisType<A & S & _StoreWithState<Id, S, G, A> & _StoreWithGetters<G> & PiniaCustomProperties>;
-}
 /**
  * Return type of `defineStore()`. Function that allows instantiating a store.
  */
 interface StoreDefinition<Id extends string = string, S extends StateTree = StateTree, G = _GettersTree<S>, A = _ActionsTree> {
   /**
    * Returns a store, creates it if necessary.
+   *
+   * @param pinia - Pinia instance to retrieve the store
+   * @param hot - dev only hot module replacement
    */
-  (): Store<Id, S, G, A>;
+  (pinia?: Pinia | null | undefined, hot?: StoreGeneric): Store<Id, S, G, A>;
   /**
    * Id of the store. Used by map helpers.
    */
@@ -44,25 +337,229 @@ interface StoreDefinition<Id extends string = string, S extends StateTree = Stat
    * Return to store for use within non-functional components
    */
   $getStore: () => Store<Id, S, G, A>;
+  /**
+   * Dev only pinia for HMR.
+   *
+   * @internal
+   */
+  _pinia?: Pinia;
+}
+/**
+ * Interface to be extended by the user when they add properties through plugins.
+ */
+interface PiniaCustomProperties<Id extends string = string, S extends StateTree = StateTree, G = _GettersTree<S>, A = _ActionsTree> {}
+/**
+ * Properties that are added to every `store.$state` by `pinia.use()`.
+ */
+interface PiniaCustomStateProperties<S extends StateTree = StateTree> {}
+/**
+ * Type of an object of Getters that infers the argument. For internal usage only.
+ * For internal use **only**
+ */
+type _GettersTree<S extends StateTree> = Record<string, ((state: UnwrapRef<S> & UnwrapRef<PiniaCustomStateProperties<S>>) => any) | (() => any)>;
+/**
+ * Type of an object of Actions. For internal usage only.
+ * For internal use **only**
+ */
+type _ActionsTree = Record<string, _Method>;
+/**
+ * Type that enables refactoring through IDE.
+ * For internal use **only**
+ */
+type _ExtractStateFromSetupStore_Keys<SS> = keyof { [K in keyof SS as SS[K] extends _Method | ComputedRef ? never : K]: any };
+/**
+ * Type that enables refactoring through IDE.
+ * For internal use **only**
+ */
+type _ExtractActionsFromSetupStore_Keys<SS> = keyof { [K in keyof SS as SS[K] extends _Method ? K : never]: any };
+/**
+ * Type that enables refactoring through IDE.
+ * For internal use **only**
+ */
+type _ExtractGettersFromSetupStore_Keys<SS> = keyof { [K in keyof SS as SS[K] extends ComputedRef ? K : never]: any };
+/**
+ * Type that enables refactoring through IDE.
+ * For internal use **only**
+ */
+type _UnwrapAll<SS> = { [K in keyof SS]: UnwrapRef<SS[K]> };
+/**
+ * For internal use **only**
+ */
+type _ExtractStateFromSetupStore<SS> = SS extends undefined | void ? {} : Pick<SS, _ExtractStateFromSetupStore_Keys<SS>>;
+/**
+ * For internal use **only**
+ */
+type _ExtractActionsFromSetupStore<SS> = SS extends undefined | void ? {} : Pick<SS, _ExtractActionsFromSetupStore_Keys<SS>>;
+/**
+ * For internal use **only**
+ */
+type _ExtractGettersFromSetupStore<SS> = SS extends undefined | void ? {} : Pick<SS, _ExtractGettersFromSetupStore_Keys<SS>>;
+/**
+ * Options passed to `defineStore()` that are common between option and setup
+ * stores. Extend this interface if you want to add custom options to both kinds
+ * of stores.
+ */
+type DefineStoreOptionsBase<S extends StateTree, Store> = {};
+/**
+ * Options parameter of `defineStore()` for option stores. Can be extended to
+ * augment stores with the plugin API. @see {@link DefineStoreOptionsBase}.
+ */
+interface DefineStoreOptions<Id extends string, S extends StateTree, G, A> extends DefineStoreOptionsBase<S, Store<Id, S, G, A>> {
+  /**
+   * Unique string key to identify the store across the application.
+   */
+  id: Id;
+  /**
+   * Function to create a fresh state. **Must be an arrow function** to ensure
+   * correct typings!
+   */
+  state?: () => S;
+  /**
+   * Optional object of getters.
+   */
+  getters?: G & ThisType<UnwrapRef<S> & _StoreWithGetters<G> & PiniaCustomProperties> & _GettersTree<S>;
+  /**
+   * Optional object of actions.
+   */
+  actions?: A & ThisType<A & UnwrapRef<S> & _StoreWithState<Id, S, G, A> & _StoreWithGetters<G> & PiniaCustomProperties>;
+  /**
+   * Allows hydrating the store during SSR when complex state (like client side only refs) are used in the store
+   * definition and copying the value from `pinia.state` isn't enough.
+   *
+   * @example
+   * If in your `state`, you use any `customRef`s, any `computed`s, or any `ref`s that have a different value on
+   * Server and Client, you need to manually hydrate them. e.g., a custom ref that is stored in the local
+   * storage:
+   *
+   * ```ts
+   * const useStore = defineStore('main', {
+   *   state: () => ({
+   *     n: useLocalStorage('key', 0)
+   *   }),
+   *   hydrate(storeState, initialState) {
+   *     // @ts-expect-error: https://github.com/microsoft/TypeScript/issues/43826
+   *     storeState.n = useLocalStorage('key', 0)
+   *   }
+   * })
+   * ```
+   *
+   * @param storeState - the current state in the store
+   * @param initialState - initialState
+   */
+  hydrate?(storeState: UnwrapRef<S>, initialState: UnwrapRef<S>): void;
 }
+/**
+ * Options parameter of `defineStore()` for setup stores. Can be extended to
+ * augment stores with the plugin API. @see {@link DefineStoreOptionsBase}.
+ */
+interface DefineSetupStoreOptions<Id extends string, S extends StateTree, G, A> extends DefineStoreOptionsBase<S, Store<Id, S, G, A>> {
+  /**
+   * Extracted actions. Added by useStore(). SHOULD NOT be added by the user when
+   * creating the store. Can be used in plugins to get the list of actions in a
+   * store defined with a setup function. Note this is always defined
+   */
+  actions?: A;
+}
+/**
+ * Available `options` when creating a pinia plugin.
+ */
+interface DefineStoreOptionsInPlugin<Id extends string, S extends StateTree, G, A> extends Omit<DefineStoreOptions<Id, S, G, A>, 'id' | 'actions'> {
+  /**
+   * Extracted object of actions. Added by useStore() when the store is built
+   * using the setup API, otherwise uses the one passed to `defineStore()`.
+   * Defaults to an empty object if no actions are defined.
+   */
+  actions: A;
+}
+/**
+ * Utility type. For internal use **only**
+ */
+//#endregion
+//#region src/rootStore.d.ts
+/**
+ * Get the currently active pinia if there is any.
+ */
+declare const getActivePinia: () => Pinia | undefined;
+/**
+ * Every application must own its own pinia to be able to create stores
+ */
+interface Pinia {
+  /**
+   * root state
+   */
+  state: Ref<Record<string, StateTree>>;
+  /**
+   * Adds a store plugin to extend every store
+   *
+   * @param plugin - store plugin to add
+   */
+  use(plugin: PiniaPlugin): Pinia;
+  /**
+   * Installed store plugins
+   *
+   * @internal
+   */
+  _p: PiniaPlugin[];
+  /**
+   * Effect scope the pinia is attached to
+   *
+   * @internal
+   */
+  _e: EffectScope;
+  /**
+   * Registry of stores used by this pinia.
+   *
+   * @internal
+   */
+  _s: Map<string, StoreGeneric>;
+  /**
+   * Added by `createTestingPinia()` to bypass `useStore(pinia)`.
+   *
+   * @internal
+   */
+  _testing?: boolean;
+}
+declare function setActivePinia(_pinia: Pinia): void;
 type PiniaPluginContext<Id extends string = string, S extends StateTree = StateTree, G = _GettersTree<S>, A = _ActionsTree> = {
-  options: DefineStoreOptions<Id, S, G, A>;
+  /**
+   * pinia instance.
+   */
+  pinia: Pinia;
+  /**
+   * Current store being extended.
+   */
   store: Store<Id, S, G, A>;
+  /**
+   * Initial options defining the store when calling `defineStore()`.
+   */
+  options: DefineStoreOptionsInPlugin<Id, S, G, A>;
 };
-type PiniaPlugin = (context: PiniaPluginContext) => Partial<PiniaCustomProperties & PiniaCustomStateProperties> | undefined;
-//#endregion
-//#region src/defineStore.d.ts
-declare function defineStore<Id extends string, S extends StateTree, G extends _GettersTree<S> = {}, A extends _ActionsTree = {}>(id: Id, options: DefineStoreOptions<Id, S, G, A>): StoreDefinition<Id, S, G, A>;
-//#endregion
-//#region src/pinia.d.ts
-interface Pinia {
-  _store: Map<string, StoreGeneric>;
-  _state: Map<string, StateTree>;
-  _plugins: Set<PiniaPlugin>;
-  use(plugin: PiniaPlugin): this;
+/**
+ * Plugin to extend every store.
+ */
+interface PiniaPlugin {
+  /**
+   * Plugin to extend every store. Returns an object to extend the store or
+   * nothing.
+   *
+   * @param context - Context
+   */
+  (context: PiniaPluginContext): Partial<PiniaCustomProperties & PiniaCustomStateProperties> | void;
 }
-declare let pinia: Pinia;
+//#endregion
+//#region src/createPinia.d.ts
+/**
+ * Creates a Pinia instance to be used by the application
+ */
 declare function createPinia(): Pinia;
-declare function setActivePinia(_pinia: Pinia): void;
 //#endregion
-export { type DefineStoreOptionsBase, type PiniaCustomProperties, type PiniaCustomStateProperties, type PiniaPlugin, type PiniaPluginContext, type StateTree, type Store, createPinia, defineStore, pinia, setActivePinia };
+//#region src/store.d.ts
+/**
+ * Creates a `useStore` function that retrieves the store instance
+ *
+ * @param id - id of the store (must be unique)
+ * @param options - options to define the store
+ */
+declare function defineStore<Id extends string, S extends StateTree = {}, G extends _GettersTree<S> = {}, A = {}>(id: Id, options: Omit<DefineStoreOptions<Id, S, G, A>, 'id'>): StoreDefinition<Id, S, G, A>;
+//#endregion
+export { type DefineSetupStoreOptions, type DefineStoreOptions, type DefineStoreOptionsBase, type DefineStoreOptionsInPlugin, MutationType, type Pinia, type PiniaCustomProperties, type PiniaCustomStateProperties, type PiniaPlugin, type PiniaPluginContext, type StateTree, type Store, type StoreDefinition, type StoreGeneric, type StoreOnActionListener, type StoreOnActionListenerContext, type StoreProperties, type SubscriptionCallback, type SubscriptionCallbackMutation, type SubscriptionCallbackMutationDirect, type SubscriptionCallbackMutationPatchFunction, type SubscriptionCallbackMutationPatchObject, type _ActionsTree, type _DeepPartial, type _ExtractActionsFromSetupStore, type _ExtractActionsFromSetupStore_Keys, type _ExtractGettersFromSetupStore, type _ExtractGettersFromSetupStore_Keys, type _ExtractStateFromSetupStore, type _ExtractStateFromSetupStore_Keys, type _GettersTree, type _Method, type _StoreOnActionListenerContext, type _StoreWithActions, type _StoreWithGetters, type _StoreWithState, type _SubscriptionCallbackMutationBase, type _UnwrapAll, createPinia, defineStore, getActivePinia, setActivePinia };

package/dist/index.js

@@ -1,162 +1 @@
-import { ReactiveEffect, activeEffect, computed, isReactive, isRef, markRaw, reactive, toRefs, watch } from "@maoism/runtime-core";
-import { useCallback, useId, useRef, useSyncExternalStore } from "react";
-import { isFunction } from "savage-types";
-import "savage-utils";
-
-//#region src/pinia.ts
-let pinia;
-function createPinia() {
-	return {
-		_store: /* @__PURE__ */ new Map(),
-		_state: /* @__PURE__ */ new Map(),
-		_plugins: /* @__PURE__ */ new Set(),
-		use(p) {
-			this._plugins.add(p);
-			return this;
-		}
-	};
-}
-function setActivePinia(_pinia) {
-	pinia = _pinia;
-}
-setActivePinia(createPinia());
-
-//#endregion
-//#region src/utils.ts
-function noop() {
-	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) && target.hasOwnProperty(key) && !isRef(subPatch) && !isReactive(subPatch)) target[key] = mergeReactiveObjects(targetValue, subPatch);
-		else target[key] = subPatch;
-	}
-	return target;
-}
-
-//#endregion
-//#region src/subscription.ts
-const subscriptions = /* @__PURE__ */ new Set();
-function addSubscriptions(callback, onCleanup = noop) {
-	subscriptions.add(callback);
-	const remove = () => {
-		subscriptions.delete(callback);
-		onCleanup();
-	};
-	return remove;
-}
-function triggerSubscription(state) {
-	subscriptions.forEach((callback) => callback(state));
-}
-
-//#endregion
-//#region src/defineStore.ts
-let isLoadingPlugin = false;
-function defineStore(id, options) {
-	let isSyncListening = false;
-	function createStore() {
-		const { state, actions, getters } = options;
-		const $state = reactive(state ? state() : {});
-		const initState = state ? state() : {};
-		const baseStore = {
-			$id: id,
-			$state,
-			$patch(val) {
-				isSyncListening = false;
-				if (isFunction(val)) val($state);
-				else mergeReactiveObjects($state, val);
-				isSyncListening = true;
-				triggerSubscription($state);
-			},
-			$reset() {
-				this.$patch((v) => {
-					Object.assign(v, initState);
-				});
-			},
-			$subscribe(cb) {
-				const remove = addSubscriptions(cb, () => unwatch());
-				const unwatch = watch($state, (state$1) => {
-					if (isSyncListening) cb(state$1);
-				}, {
-					deep: true,
-					flush: "sync"
-				});
-				return remove;
-			}
-		};
-		pinia._state.set(id, $state);
-		const store = reactive(Object.assign(baseStore, toRefs($state), Object.keys(actions ?? []).reduce((x, y) => Object.assign(x, { [y]: (...args) => actions[y].call(store, ...args) }), {}), Object.keys(getters || {}).reduce((computedGetters, name) => {
-			computedGetters[name] = markRaw(computed(() => {
-				return getters?.[name].call(store, store);
-			}));
-			return computedGetters;
-		}, {})));
-		const lastLoadingPlugin = isLoadingPlugin;
-		isLoadingPlugin = true;
-		pinia._plugins.forEach((p) => {
-			Object.assign(store, p({
-				store,
-				options
-			}) || {});
-		});
-		isLoadingPlugin = lastLoadingPlugin;
-		pinia._store.set(id, store);
-	}
-	const effectMap = /* @__PURE__ */ new WeakMap();
-	const subscribeMap = /* @__PURE__ */ new WeakMap();
-	function useStore() {
-		if (!pinia._store.has(id)) createStore();
-		const store = pinia._store.get(id);
-		isSyncListening = true;
-		const _id = useRef([useId()]);
-		const storeSnapshotRef = useRef({ ...store });
-		const isCollectDep = useRef(false);
-		const subscribe = useCallback((onStoreChange) => {
-			subscribeMap.set(_id.current, onStoreChange);
-			return () => {
-				const effect$1 = effectMap.get(_id.current);
-				if (effect$1) effect$1.stop();
-				subscribeMap.delete(_id.current);
-				effectMap.delete(_id.current);
-			};
-		}, []);
-		useSyncExternalStore(subscribe, () => storeSnapshotRef.current, () => storeSnapshotRef.current);
-		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, noop, () => {
-				if (effect?.dirty) effect.run();
-			});
-			activeEffect.value = effect;
-			isCollectDep.current = true;
-			effect.run();
-			effectMap.set(_id.current, effect);
-			isCollectDep.current = false;
-		}
-		return store;
-	}
-	useStore.$id = id;
-	useStore.$getStore = () => {
-		if (!pinia._store.has(id)) createStore();
-		const store = pinia._store.get(id);
-		return store;
-	};
-	return useStore;
-}
-
-//#endregion
-export { createPinia, defineStore, pinia, setActivePinia };
+import{ReactiveEffect as e,activeEffect as t,computed as n,effectScope as r,isReactive as i,isRef as a,markRaw as o,nextTick as s,reactive as c,ref as l,toRaw as u,toRefs as d,watch as f}from"@maoism/runtime-core";import{useCallback as p,useId as m,useRef as h,useSyncExternalStore as g}from"react";import"savage-types";import"savage-utils";const _=()=>v;let v;function y(e){v=e}function b(){let e=r(!0),t=e.run(()=>l({})),n=[],i=o({use(e){return n.push(e),this},_p:n,_e:e,_s:new Map,state:t});return y(i),i}const x=()=>{};function S(e,t,n,r=x){e.add(t);let i=()=>{e.delete(t),r()};return i}function C(e,...t){e.forEach(e=>{e(...t)})}let w=function(e){return e.direct=`direct`,e.patchObject=`patch object`,e.patchFunction=`patch function`,e}({});function T(){return{}}function E(e){return e&&typeof e==`object`&&Object.prototype.toString.call(e)===`[object Object]`&&typeof e.toJSON!=`function`}function D(e,t){for(let n in e instanceof Map&&t instanceof Map&&t.forEach((t,n)=>e.set(n,t)),e instanceof Set&&t instanceof Set&&t.forEach(e.add,e),t){if(!Object.hasOwn(t,n))continue;let r=t[n],o=e[n];E(o)&&E(r)&&e.hasOwnProperty(n)&&!a(r)&&!i(r)?e[n]=D(o,r):e[n]=r}return e}const O=Symbol(),k=Symbol(),{assign:A}=Object;function j(e,t,r){let{state:i,actions:a,getters:s}=t,c=r.state.value[e],l;function u(){c||(r.state.value[e]=i?i():{});let t=d(r.state.value[e]);return A(t,a,Object.keys(s||{}).reduce((t,i)=>(t[i]=o(n(()=>{y(r);let t=r._s.get(e);return s[i].call(t,t)})),t),{}))}return l=M(e,u,t,r),l}function M(e,t,n={},i){let a,o=A({actions:{}},n),l={deep:!0},d,p,m=new Set,h=new Set,g=[],_;function v(t){let n;d=p=!1,typeof t==`function`?(t(i.state.value[e]),n={type:w.patchFunction,storeId:e,events:g}):(D(i.state.value[e],t),n={type:w.patchObject,payload:t,storeId:e,events:g}),_=Symbol();let r=_;s().then(()=>{_===r&&(d=!0)}),p=!0,C(m,n,i.state.value[e])}let b=function(){let{state:e}=n,t=e?e():{};this.$patch(e=>{A(e,t)})},x=(t,n=``)=>{if(O in t)return t[k]=n,t;let r=function(){y(i);let n=Array.from(arguments),a=new Set,o=new Set;function s(e){a.add(e)}function c(e){o.add(e)}C(h,{args:n,name:r[k],store:E,after:s,onError:c});let l;try{l=t.apply(this&&this.$id===e?this:E,n)}catch(e){throw C(o,e),e}return l instanceof Promise?l.then(e=>(C(a,e),e)).catch(e=>(C(o,e),Promise.reject(e))):(C(a,l),l)};return r[O]=!0,r[k]=n,r},T={_p:i,$id:e,$onAction:S.bind(null,h),$patch:v,$reset:b,$subscribe(t,n={}){let r=S(m,t,n.detached,()=>o()),o=a.run(()=>f(()=>i.state.value[e],r=>{(n.flush===`sync`?p:d)&&t({storeId:e,type:w.direct,events:g},r)},A({},l,n)));return r}},E=c(T);i._s.set(e,E),a=r();let j=a.run(()=>t({action:x}));for(let e in j){let t=j[e];if(typeof t==`function`){let n=x(t,e);j[e]=n,o.actions[e]=t}}return A(E,j),A(u(E),j),Object.defineProperty(E,`$state`,{get:()=>i.state.value[e],set:e=>{v(t=>{A(t,e)})}}),i._p.forEach(e=>{A(E,a.run(()=>e({store:E,pinia:i,options:o})))}),d=!0,p=!0,E}function N(n,r){let i=new WeakMap,a=new WeakMap;function o(o){o&&y(o),o=v;let s=t.value;t.value=void 0,o._s.has(n)||j(n,r,o),t.value=s;let c=o._s.get(n),l=h([m()]),u=h({...c}),d=h(!1),f=p(e=>(a.set(l.current,e),()=>{let e=i.get(l.current);e&&e.stop(),a.delete(l.current),i.delete(l.current)}),[]);g(f,()=>u.current,()=>u.current);let _=i.get(l.current);if(!_){let n=()=>{let e=a.get(l.current);d.current||(u.current={...c},e?.())};_=new e(n,T,()=>{_?.dirty&&_.run()}),t.value=_,d.current=!0,_.run(),i.set(l.current,_),d.current=!1}return c}return o.$id=n,o.$getStore=e=>{e&&y(e),e=v,e._s.has(n)||j(n,r,e);let t=e._s.get(n);return t},o}export{w as MutationType,b as createPinia,N as defineStore,_ as getActivePinia,y as setActivePinia};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinia-react",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "type": "module",
   "homepage": "https://github.com/savageKarl/pinia-react#readme",
   "bugs": {
@@ -28,7 +28,7 @@
     "prepare": "npx simple-git-hooks",
     "build": "tsdown",
     "dev": "tsdown --watch",
-    "playground-react": "vite --config playground/react/vite.config.ts",
+    "playground-react": "vite playground/react",
     "playground-nextjs": "pnpm next dev ./playground/nextjs",
     "test": "vitest",
     "semantic-release": "semantic-release",
@@ -67,7 +67,7 @@
     "simple-git-hooks": "^2.13.1",
     "tsdown": "^0.13.3",
     "typescript": "^5.8.3",
-    "vite": "npm:rolldown-vite@latest",
+    "vite": "^7.1.2",
     "vitest": "^3.2.4"
   },
   "dependencies": {