added store options functions with scope

Author: unstoppablecarl

README.md

@@ -107,7 +107,7 @@ const vehicleStoreWithComponentScope = useVehicleStore()
 
 ```ts
 // vehicle-store.ts
-import { type StoreCreatorContext } from 'pinia-scope'
+import { type StoreCreatorContext, defineScopeableStore } from 'pinia-scope'
 import { useTireStore } from 'tire-store.ts'
 
 export const useVehicleStore = defineScopeableStore('vehicles', ({ scope }: StoreCreatorContext) => {
@@ -278,6 +278,23 @@ const vehicleStoreUnscoped = useVehicleStore.componentScoped()
 const vehicleStoreScoped = useVehicleStore('my-scope')
 ```
 
+
+### Pinia Plugins
+The scope can be used to determine plugin options by passing a function as the store options argument.
+```ts
+// main.js
+import { defineScopeableStore } from 'pinia-scope'
+
+export const useVehicleStore = defineScopeableStore('vehicles', ({ scope }: StoreCreatorContext) => {
+  
+  // ...
+}, (scope: string) => {
+  return {
+    somePluginOption: scope === 'foo'
+  }
+})
+```
+
 ## API
 
 All API methods (excluding `attachPiniaScope()`) will work inside a vue component or a context where [getActivePinia()](https://pinia.vuejs.org/api/pinia/functions/getActivePinia.html#getActivePinia-) will return a result.

examples/vehicle-editor/package.json

@@ -18,6 +18,7 @@
     "@vitejs/plugin-vue": "^6.0.0",
     "@vue/tsconfig": "^0.7.0",
     "file-saver": "^2.0.5",
+    "pinia-plugin-persistedstate": "^4.5.0",
     "sass": "^1.77.6",
     "typescript": "~5.8.3",
     "vite": "^7.0.3",

examples/vehicle-editor/src/main.ts

@@ -4,9 +4,11 @@ import { createPinia } from 'pinia'
 
 import './scss/styles.scss'
 import { attachPiniaScope } from 'pinia-scope'
+import piniaPluginPersistedstate from 'pinia-plugin-persistedstate';
 
 const app = createApp(App)
 const pinia = createPinia()
+pinia.use(piniaPluginPersistedstate);
 
 attachPiniaScope(pinia)
 app.use(pinia)

examples/vehicle-editor/src/store/engine-store.ts

@@ -126,5 +126,9 @@ export const useEngineStore = defineScopeableStore('engines', ({ scope }) => {
     get,
     $reset,
   }
+}, (scope: string) => {
+  return {
+    persist: scope === '',
+  }
 })
 

examples/vehicle-editor/src/store/vehicle-store.ts

@@ -92,5 +92,9 @@ export const useVehicleStore = defineScopeableStore('vehicles', ({ scope }) => {
     get,
     getInfo,
   }
+}, (scope: string) => {
+  return {
+    persist: scope === '',
+  }
 })
 

package.json

@@ -1,8 +1,8 @@
 {
   "name": "pinia-scope",
   "type": "module",
-  "version": "1.5.1",
-  "packageManager": "pnpm@10.13.1",
+  "version": "1.6.0",
+  "packageManager": "pnpm@10.14.0",
   "description": "Scoped Pinia Stores for Vue",
   "author": {
     "name": "Carl Olsen",

pnpm-lock.yaml

@@ -1,5 +1,4 @@
 import { defineStore } from 'pinia'
-import { type ScopeOptionsInput } from '../scope-options'
 import {
   makeStoreFactory,
   type ScopeableStoreOptions,
@@ -16,9 +15,12 @@ export function defineNonScopeableStore<Id extends string, SS, SD extends StoreD
   storeCreator: (context: NonScopeContext) => SS,
   setupOptions?: ScopeableStoreOptions<Id, SS>,
 ): ScopeableStoreResult<S> {
-  function makeStore(scope: string, options?: ScopeOptionsInput) {
+  function makeStore(scope: string) {
     if (scope === '') {
       let setup = (): SS => storeCreator({ unScoped: '' })
+      if (typeof setupOptions === 'function') {
+        setupOptions = setupOptions(scope)
+      }
       const useStore = defineStore(id, setup, setupOptions) as SD
       return useStore() as S
     }

src/functions/defineNonScopeableStore.ts

@@ -17,13 +17,21 @@ export type ScopedContext = {
   scope: string;
 }
 
-export type ScopeableStoreOptions<Id extends string, SS> = DefineSetupStoreOptions<
+export type ScopeableStoreOptions<Id extends string, SS> =
+  ScopeableStoreOptionsObject<Id, SS>
+  | ScopeableStoreOptionsCreator<Id, SS>
+
+export type ScopeableStoreOptionsObject<Id extends string, SS> = DefineSetupStoreOptions<
   Id,
   _ExtractStateFromSetupStore<SS>,
   _ExtractGettersFromSetupStore<SS>,
   _ExtractActionsFromSetupStore<SS>
 >
 
+export interface ScopeableStoreOptionsCreator<Id extends string, SS> {
+  (scope: string): ScopeableStoreOptionsObject<Id, SS>
+}
+
 export type ScopeableStoreResult<S> = {
   (scope?: string, options?: ScopeOptionsInput): S;
   componentScoped(): S;
@@ -66,6 +74,10 @@ export function defineScopeableStore<Id extends string, SS, SD extends StoreDef<
         }
       }
     }
+    if (typeof setupOptions === 'function') {
+      setupOptions = setupOptions(scope)
+    }
+
     const useStore = defineStore(scopedId, setup, setupOptions) as SD
     const store = useStore() as S
 

src/functions/defineScopeableStore.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { defineNonScopeableStore } from '../../src/functions/defineNonScopeableStore'
-import { createPinia, setActivePinia } from 'pinia'
+import { createPinia, type PiniaPluginContext, setActivePinia } from 'pinia'
 import { attachPiniaScope } from '../../src/pinia-scope'
 import { mount } from '@vue/test-utils'
 import { setComponentScope } from '../../src'
@@ -103,4 +103,45 @@ describe('defineNonScopeableStore()', () => {
     }).toThrowError(`Attempting to use un-scopeable store (store id: "${TEST_STORE_ID}") with scope "${SCOPE_A}".`)
   })
 
+  it('handles plugin options function', async () => {
+    let count = 0
+    const options = {
+      foo: {
+        some: 'thing',
+      },
+    }
+
+    function testPiniaPlugin(context: PiniaPluginContext) {
+      count++
+      expect(context.options).toEqual({
+        actions: {},
+        scope: '',
+        ...options,
+      })
+    }
+
+    const pinia = createPinia()
+    attachPiniaScope(pinia, {
+      autoInjectScope: true,
+    })
+    pinia.use(testPiniaPlugin)
+    setActivePinia(pinia)
+    mount({ template: 'none' }, { global: { plugins: [pinia] } })
+
+    const useTestStore = defineNonScopeableStore('test', (context) => {
+      return {
+        a: 'b',
+      }
+      // @ts-expect-error
+    }, (scope: string) => {
+      return {
+        scope,
+        ...options,
+      }
+    })
+
+    const store = useTestStore()
+    expect(count).toBe(1)
+  })
+
 })