vue-context-storage 0.1.33 → 0.1.35

package/README.md

@@ -52,7 +52,7 @@ In Vue applications, reactive state often needs to live beyond a single componen
 - **URL query parameters** stay in sync with your data automatically - users can bookmark or share a page and get the exact same state back.
 - **localStorage and sessionStorage** are kept up to date without manual `getItem`/`setItem` calls, including cross-tab synchronization.
 - **Type safety** is preserved end-to-end: URL strings are coerced back to numbers, booleans, and arrays via transform helpers or Zod schemas.
-- **Multiple independent contexts** (e.g. two data tables on the same page) are supported out of the box through the prefix pattern, so query parameters never collide.
+- **Multiple independent contexts** (e.g. two data tables on the same page) are supported out of the box through the key pattern, so query parameters never collide.
 
 The goal is a single, declarative API - `useContextStorage('query', data, options)` - that replaces scattered watchers, router guards, and storage listeners with one composable call per piece of state.
 
@@ -118,7 +118,7 @@ const filters = reactive({
 
 // Sync with URL query
 useContextStorage('query', filters, {
-  prefix: 'filters',
+  key: 'filters',
 })
 
 // Sync with localStorage
@@ -141,7 +141,7 @@ You can also pass an injection key directly instead of a string:
 import { contextStorageQueryHandlerInjectKey } from 'vue-context-storage'
 
 useContextStorage(contextStorageQueryHandlerInjectKey, filters, {
-  prefix: 'filters',
+  key: 'filters',
 })
 ```
 
@@ -181,11 +181,11 @@ The `<ContextStoragePrefix>` component adds a prefix to all `useContextStorage`
 </template>
 ```
 
-Inside `MyTable`, any `useContextStorage('query', data)` call will automatically get `prefix: 'tables'`. If the composable also specifies its own prefix, they are combined:
+Inside `MyTable`, any `useContextStorage('query', data)` call will automatically get `key: 'tables'`. If the composable also specifies its own key, they are combined:
 
 ```typescript
-// Inside MyTable — effective prefix becomes 'table[filters]'
-useContextStorage('query', filters, { prefix: 'filters' })
+// Inside MyTable — effective key becomes 'table[filters]'
+useContextStorage('query', filters, { key: 'filters' })
 // URL: ?table[filters][search]=...
 ```
 
@@ -248,21 +248,11 @@ const filters = reactive<Filters>({
 
 // Automatically syncs filters with URL query
 useContextStorage('query', filters, {
-  prefix: 'filters', // URL will be: ?filters[search]=...&filters[status]=...
+  key: 'filters', // URL will be: ?filters[search]=...&filters[status]=...
 })
 </script>
 ```
 
-Also available as a dedicated composable:
-
-```typescript
-import { useContextStorageQueryHandler } from 'vue-context-storage'
-
-useContextStorageQueryHandler(filters, {
-  prefix: 'filters',
-})
-```
-
 ## Advanced Usage
 
 ### Using Transform Helpers
@@ -286,7 +276,7 @@ const state = ref<TableState>({
 })
 
 useContextStorage('query', state, {
-  prefix: 'table',
+  key: 'table',
   transform: (deserialized, initial) => ({
     page: transform.asNumber(deserialized.page, { fallback: 1 }),
     search: transform.asString(deserialized.search, { fallback: '' }),
@@ -302,6 +292,7 @@ useContextStorage('query', state, {
 - `asBoolean(value, options)` - Convert to boolean
 - `asArray(value, options)` - Convert to array
 - `asNumberArray(value, options)` - Convert to number array
+- `asObjectArray(value, options)` - Convert indexed object to array of objects (see [Arrays of Objects](#arrays-of-objects))
 
 ### Using Zod Schemas
 
@@ -322,7 +313,7 @@ const filters = ref(FiltersSchema.parse({}))
 
 // Use schema for automatic validation
 useContextStorage('query', filters, {
-  prefix: 'filters',
+  key: 'filters',
   schema: FiltersSchema,
 })
 ```
@@ -335,25 +326,104 @@ useContextStorage('query', filters, {
 - Less boilerplate code
 - Single source of truth for structure and validation
 
+### Arrays of Objects
+
+The query handler supports arrays of objects. They are serialized as indexed query parameters:
+
+```
+?items[0][product]=Apple&items[0][quantity]=5&items[1][product]=Banana&items[1][quantity]=10
+```
+
+After deserialization, URL parameters produce indexed objects (`{ '0': {...}, '1': {...} }`) rather than arrays. Use `transform.asObjectArray` or the Zod helper `zObjectArray` to convert them back.
+
+**With transform helpers:**
+
+```typescript
+import { reactive } from 'vue'
+import { useContextStorage, transform } from 'vue-context-storage'
+
+const data = reactive({
+  title: '',
+  items: [] as { product: string; quantity: number }[],
+})
+
+useContextStorage('query', data, {
+  transform: (value) => ({
+    title: transform.asString(value.title),
+    items: transform.asObjectArray(value.items, (entry) => ({
+      product: transform.asString(entry.product),
+      quantity: transform.asNumber(entry.quantity),
+    })),
+  }),
+})
+```
+
+`asObjectArray` also supports a callback shorthand — pass a function as the second argument instead of an options object.
+
+**With Zod schema:**
+
+```typescript
+import { z } from 'zod'
+import { zObjectArray } from 'vue-context-storage/zod'
+
+const ItemSchema = z.object({
+  product: z.string().default(''),
+  quantity: z.coerce.number().default(0),
+})
+
+const DataSchema = z.object({
+  title: z.string().default(''),
+  items: zObjectArray(ItemSchema),
+})
+
+useContextStorage('query', data, { schema: DataSchema })
+```
+
+See [Zod Helpers](#zod-helpers-vue-context-storagezod) for more details.
+
 ### Preserve Empty State
 
 Keep empty state in URL to prevent resetting on reload:
 
 ```typescript
 useContextStorage('query', filters, {
-  prefix: 'filters',
+  key: 'filters',
   preserveEmptyState: true,
   // Empty filters will show as: ?filters
   // Without this option, empty filters would clear the URL completely
 })
 ```
 
+### Additional Default Data
+
+When `onlyChanges` is enabled (the default), a key is omitted from the URL if its current value matches the initial snapshot. `additionalDefaultData` lets you specify extra values that should also be treated as defaults and excluded from the URL.
+
+This is useful when the initial reactive data starts with `undefined` (e.g. before an API response), but you also want a specific value (like `1`) to be considered a default:
+
+```typescript
+const data = ref({ page: undefined as number | undefined })
+
+useContextStorage('query', data, {
+  key: 'filters',
+  onlyChanges: true,
+  additionalDefaultData: { page: 1 },
+})
+
+// page=undefined → not in query (matches initial)
+// page=1         → not in query (matches additionalDefaultData)
+// page=2         → appears in query as ?filters[page]=2
+```
+
 ### Configure Query Handler
 
 Customize behavior by passing options to the factory:
 
 ```typescript
-import { createQueryHandler, createLocalStorageHandler, createSessionStorageHandler } from 'vue-context-storage'
+import {
+  createQueryHandler,
+  createLocalStorageHandler,
+  createSessionStorageHandler,
+} from 'vue-context-storage'
 
 const customHandlers = [
   createQueryHandler({
@@ -391,16 +461,6 @@ useContextStorage('localStorage', settings, {
 </script>
 ```
 
-Also available as a dedicated composable:
-
-```typescript
-import { useContextStorageLocalStorage } from 'vue-context-storage'
-
-useContextStorageLocalStorage(settings, {
-  key: 'app-settings',
-})
-```
-
 ### Configure localStorage Handler
 
 ```typescript
@@ -433,36 +493,26 @@ useContextStorage('sessionStorage', formDraft, {
 </script>
 ```
 
-Also available as a dedicated composable:
+### Multiple Registrations Under One Root Key
 
-```typescript
-import { useContextStorageSessionStorage } from 'vue-context-storage'
-
-useContextStorageSessionStorage(formDraft, {
-  key: 'contact-form-draft',
-})
-```
-
-### Using Prefix
-
-The prefix is appended to the storage key in bracket notation, so each prefixed registration gets its own storage entry:
+Use bracket notation in `key` to store multiple data objects under a common root:
 
 ```typescript
 const filters = reactive({ search: '', status: 'active' })
 
 useContextStorage('sessionStorage', filters, {
-  key: 'app-state',
-  prefix: 'filters', // Storage key: 'app-state[filters]', value: { search: '', status: 'active' }
+  key: 'app-state[filters]', // Storage key: 'app-state[filters]'
 })
 
 const pagination = reactive({ page: 1, perPage: 25 })
 
 useContextStorage('sessionStorage', pagination, {
-  key: 'app-state',
-  prefix: 'pagination', // Storage key: 'app-state[pagination]', value: { page: 1, perPage: 25 }
+  key: 'app-state[pagination]', // Storage key: 'app-state[pagination]'
 })
 ```
 
+Or use `<ContextStoragePrefix>` for automatic scoping (see [Prefix Scoping](#prefix-scoping-with-contextstorageprefix)).
+
 ### Using Transform with Storage Handlers
 
 Convert stored values to proper types when reading from storage:
@@ -488,7 +538,7 @@ useContextStorage('localStorage', settings, {
 
 ```typescript
 import { z } from 'zod'
-import { useContextStorageLocalStorage } from 'vue-context-storage'
+import { useContextStorage } from 'vue-context-storage'
 
 const SettingsSchema = z.object({
   theme: z.enum(['light', 'dark']).default('light'),
@@ -542,19 +592,6 @@ Unified composable that delegates to the correct handler based on `type`.
 - `defineContextStorageHandler(name, injectionKey)` - Register a custom handler
 - `resolveHandlerInjectionKey(type)` - Look up an injection key by name
 
-#### `useContextStorageQueryHandler<T>(data, options)`
-
-Registers reactive data for URL query synchronization.
-
-**Parameters:**
-
-- `data: MaybeRefOrGetter<T>` - Reactive reference to sync
-- `options?: RegisterQueryHandlerOptions<T>`
-  - `prefix?: string` - Query parameter prefix
-  - `transform?: (deserialized, initial) => T` - Transform function
-  - `preserveEmptyState?: boolean` - Keep empty state in URL
-  - `mergeOnlyExistingKeysWithoutTransform?: boolean` - Only merge existing keys (default: true)
-
 ### Handler Factories
 
 #### `createQueryHandler(options?)`
@@ -585,25 +622,6 @@ Creates a sessionStorage handler factory.
 
 - `listenToStorageEvents?: boolean` - Listen to storage events (default: `false`)
 
-#### `useContextStorageLocalStorage<T>(data, options)`
-
-Registers reactive data for localStorage synchronization.
-
-**Parameters:**
-
-- `data: MaybeRefOrGetter<T>` - Reactive reference to sync
-- `options: RegisterWebStorageHandlerBaseOptions<T>`
-  - `key: string` - Storage key (required)
-  - `prefix?: string` - Appended to the storage key in bracket notation (e.g. key `'app'` + prefix `'filters'` = storage key `'app[filters]'`)
-  - `transform?: (deserialized, initial) => T` - Transform function
-  - `schema?: ZodSchema` - Zod schema for validation
-  - `serializer?: (data: T) => string` - Custom serializer (default: `JSON.stringify`)
-  - `deserializer?: (str: string) => unknown` - Custom deserializer (default: `JSON.parse`)
-
-#### `useContextStorageSessionStorage<T>(data, options)`
-
-Registers reactive data for sessionStorage synchronization. Same options as `useContextStorageLocalStorage`.
-
 ### Components
 
 #### `<ContextStoragePrefix>`
@@ -628,6 +646,91 @@ transform.asNumber(value, {
 })
 ```
 
+## Zod Helpers (`vue-context-storage/zod`)
+
+The library provides a separate entry point with Zod-specific helpers. Since `zod` is an optional peer dependency, these helpers are isolated in `vue-context-storage/zod` to avoid importing Zod in the main bundle.
+
+```bash
+npm install zod
+```
+
+### `zObjectArray(itemSchema)`
+
+Creates a Zod schema for arrays of objects serialized as indexed query parameters. Wraps `z.record()` + `.transform()` to convert indexed objects back to sorted arrays.
+
+```typescript
+import { z } from 'zod'
+import { zObjectArray } from 'vue-context-storage/zod'
+
+const ItemSchema = z.object({
+  product: z.string().default(''),
+  quantity: z.coerce.number().default(0),
+})
+
+const DataSchema = z.object({
+  title: z.string().default(''),
+  items: zObjectArray(ItemSchema),
+})
+```
+
+### `zUrlBoolean(defaultValue?)`
+
+Creates a Zod schema for booleans serialized as URL query parameters. Standard `z.coerce.boolean()` cannot be used because `Boolean('0')` is `true` in JavaScript. This helper correctly handles `'1'`, `'true'`, `'0'`, `'false'`, and native booleans.
+
+```typescript
+import { z } from 'zod'
+import { zUrlBoolean } from 'vue-context-storage/zod'
+
+const Schema = z.object({
+  active: zUrlBoolean(), // defaults to false
+  enabled: zUrlBoolean(true), // defaults to true
+})
+```
+
+### `createSchemaObject(schema, options?)`
+
+Creates a plain object with empty/default values based on a Zod schema. Useful for initializing reactive data from a schema definition.
+
+```typescript
+import { z } from 'zod'
+import { createSchemaObject } from 'vue-context-storage/zod'
+
+const FiltersSchema = z.object({
+  search: z.string().default(''),
+  page: z.coerce.number().default(1),
+  active: z.boolean().default(false),
+  score: z.number().nullable(),
+})
+
+const filters = reactive(createSchemaObject(FiltersSchema))
+// Result: { search: '', page: 1, active: false, score: null }
+```
+
+**Options:**
+
+- `useDefaults` (default: `true`) — When `true`, uses `.default()` values from the schema. When `false`, uses type-based empty values (`''` for strings, `0` for numbers, `false` for booleans, etc.).
+- `withSchema` (default: `false`) — When `true`, attaches the schema to the result object via `SCHEMA_SYMBOL` (wrapped with `markRaw`). Nested objects also receive their respective schemas.
+
+```typescript
+import { createSchemaObject, SCHEMA_SYMBOL } from 'vue-context-storage/zod'
+
+const data = createSchemaObject(FiltersSchema, { withSchema: true })
+data[SCHEMA_SYMBOL] // → FiltersSchema
+```
+
+**Type-based defaults** (when `useDefaults: false` or no `.default()` is set):
+
+| Zod type      | Default value                                |
+| ------------- | -------------------------------------------- |
+| `z.string()`  | `''`                                         |
+| `z.number()`  | `0` (respects `.min()` / `.positive()`)      |
+| `z.boolean()` | `false`                                      |
+| `z.array()`   | `[]`                                         |
+| `z.object()`  | Recursively created via `createSchemaObject` |
+| `z.date()`    | `null`                                       |
+| `.nullable()` | `null`                                       |
+| `.optional()` | `undefined`                                  |
+
 ## TypeScript Support
 
 Full TypeScript support with type inference:
@@ -658,7 +761,7 @@ type Filters = z.infer<typeof FiltersSchema>
 
 ```typescript
 import { ref } from 'vue'
-import { useContextStorageQueryHandler, transform } from 'vue-context-storage'
+import { useContextStorage, transform } from 'vue-context-storage'
 
 const pagination = ref({
   page: 1,
@@ -666,8 +769,8 @@ const pagination = ref({
   total: 0,
 })
 
-useContextStorageQueryHandler(pagination, {
-  prefix: 'page',
+useContextStorage('query', pagination, {
+  key: 'page',
   transform: (data, initial) => ({
     page: transform.asNumber(data.page, { fallback: 1 }),
     perPage: transform.asNumber(data.perPage, { fallback: 25 }),

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import * as vue9 from "vue";
+import * as vue29 from "vue";
 import { ComputedRef, InjectionKey, MaybeRefOrGetter, Plugin, PropType, UnwrapNestedRefs } from "vue";
 import { LocationQuery, LocationQueryValue } from "vue-router";
 
 //#region src/components/ContextStorageActivator.vue.d.ts
 declare const _default$1: typeof __VLS_export$4;
-declare const __VLS_export$4: vue9.DefineComponent<{}, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
+declare const __VLS_export$4: vue29.DefineComponent<{}, () => vue29.VNode<vue29.RendererNode, vue29.RendererElement, {
   [key: string]: any;
-}>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {}, string, vue9.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
+}>, {}, {}, {}, vue29.ComponentOptionsMixin, vue29.ComponentOptionsMixin, {}, string, vue29.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue29.ComponentProvideOptions, true, {}, any>;
 //#endregion
 //#region src/handlers/types.d.ts
 interface HandlerSchema<T> {
@@ -43,8 +43,8 @@ interface RegisterBaseOptions<T> {
    *   status: z.enum(['active', 'inactive']).default('active'),
    * })
    *
-   * useContextStorageQueryHandler(filters, {
-   *   prefix: 'filters',
+   * useContextStorage('query', filters, {
+   *   key: 'filters',
    *   schema: FiltersSchema,
    * })
    * ```
@@ -65,55 +65,55 @@ interface ContextStorageHandler<T, O> {
 //#endregion
 //#region src/components/ContextStorageCollection.vue.d.ts
 declare const _default$2: typeof __VLS_export$3;
-declare const __VLS_export$3: vue9.DefineComponent<vue9.ExtractPropTypes<{
+declare const __VLS_export$3: vue29.DefineComponent<vue29.ExtractPropTypes<{
   handlers: {
     type: PropType<ContextStorageHandlerFactory[]>;
     default: () => ContextStorageHandlerFactory<{}, RegisterOptions<{}>>[];
   };
-}>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
+}>, () => vue29.VNode<vue29.RendererNode, vue29.RendererElement, {
   [key: string]: any;
-}>[] | undefined, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {}, string, vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
+}>[] | undefined, {}, {}, {}, vue29.ComponentOptionsMixin, vue29.ComponentOptionsMixin, {}, string, vue29.PublicProps, Readonly<vue29.ExtractPropTypes<{
   handlers: {
     type: PropType<ContextStorageHandlerFactory[]>;
     default: () => ContextStorageHandlerFactory<{}, RegisterOptions<{}>>[];
   };
 }>> & Readonly<{}>, {
   handlers: ContextStorageHandlerFactory<{}, RegisterOptions<{}>>[];
-}, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, string, vue29.ComponentProvideOptions, true, {}, any>;
 //#endregion
 //#region src/components/ContextStorageProvider.vue.d.ts
 declare const _default$4: typeof __VLS_export$2;
-declare const __VLS_export$2: vue9.DefineComponent<vue9.ExtractPropTypes<{
+declare const __VLS_export$2: vue29.DefineComponent<vue29.ExtractPropTypes<{
   itemKey: {
     type: StringConstructor;
     required: true;
   };
-}>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
+}>, () => vue29.VNode<vue29.RendererNode, vue29.RendererElement, {
   [key: string]: any;
-}>[] | undefined, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {}, string, vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
+}>[] | undefined, {}, {}, {}, vue29.ComponentOptionsMixin, vue29.ComponentOptionsMixin, {}, string, vue29.PublicProps, Readonly<vue29.ExtractPropTypes<{
   itemKey: {
     type: StringConstructor;
     required: true;
   };
-}>> & Readonly<{}>, {}, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue29.ComponentProvideOptions, true, {}, any>;
 //#endregion
 //#region src/components/ContextStorage.vue.d.ts
 declare const _default: typeof __VLS_export$1;
-declare const __VLS_export$1: vue9.DefineComponent<vue9.ExtractPropTypes<{
+declare const __VLS_export$1: vue29.DefineComponent<vue29.ExtractPropTypes<{
   handlers: {
     type: PropType<ContextStorageHandlerFactory[]>;
     default: () => ContextStorageHandlerFactory<{}, RegisterOptions<{}>>[];
   };
-}>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
+}>, () => vue29.VNode<vue29.RendererNode, vue29.RendererElement, {
   [key: string]: any;
-}>[] | undefined, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {}, string, vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
+}>[] | undefined, {}, {}, {}, vue29.ComponentOptionsMixin, vue29.ComponentOptionsMixin, {}, string, vue29.PublicProps, Readonly<vue29.ExtractPropTypes<{
   handlers: {
     type: PropType<ContextStorageHandlerFactory[]>;
     default: () => ContextStorageHandlerFactory<{}, RegisterOptions<{}>>[];
   };
 }>> & Readonly<{}>, {
   handlers: ContextStorageHandlerFactory<{}, RegisterOptions<{}>>[];
-}, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, string, vue29.ComponentProvideOptions, true, {}, any>;
 //#endregion
 //#region src/prefix.d.ts
 /**
@@ -129,26 +129,25 @@ type ContextStoragePrefixSegment = string | Partial<Record<string, string>>;
  * bracket notation (`a[b][c]`).
  *
  * @param segments — array provided via inject (stacked by nested ContextStoragePrefix components)
- * @param handlerInjectionKey — injection key of the handler to resolve for
- * @param knownHandlerKeys — mapping from injection key to handler type name
+ * @param handlerType — handler type name (e.g. 'query', 'localStorage')
  */
 declare const contextStoragePrefixSegmentsInjectKey: InjectionKey<MaybeRefOrGetter<ContextStoragePrefixSegment[]>>;
 //#endregion
 //#region src/components/ContextStoragePrefix.vue.d.ts
 declare const _default$3: typeof __VLS_export;
-declare const __VLS_export: vue9.DefineComponent<vue9.ExtractPropTypes<{
+declare const __VLS_export: vue29.DefineComponent<vue29.ExtractPropTypes<{
   name: {
     type: PropType<ContextStoragePrefixSegment>;
     required: true;
   };
-}>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
+}>, () => vue29.VNode<vue29.RendererNode, vue29.RendererElement, {
   [key: string]: any;
-}>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {}, string, vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
+}>, {}, {}, {}, vue29.ComponentOptionsMixin, vue29.ComponentOptionsMixin, {}, string, vue29.PublicProps, Readonly<vue29.ExtractPropTypes<{
   name: {
     type: PropType<ContextStoragePrefixSegment>;
     required: true;
   };
-}>> & Readonly<{}>, {}, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue29.ComponentProvideOptions, true, {}, any>;
 //#endregion
 //#region src/plugin.d.ts
 declare const VueContextStoragePlugin: Plugin;
@@ -205,7 +204,7 @@ interface QueryHandlerSharedOptions {
    * Useful, when you have default values, and want to preserve empty state in query.
    * @example
    * ```
-   * Options: {preserveEmptyState: true, prefix: 'filters'}
+   * Options: {preserveEmptyState: true, key: 'filters'}
    *
    * When filters are empty we will get this in query string:
    *
@@ -216,7 +215,7 @@ interface QueryHandlerSharedOptions {
    *
    * @example
    * ```
-   * Options: {preserveEmptyState: false, prefix: 'filters'}
+   * Options: {preserveEmptyState: false, key: 'filters'}
    *
    * When filters are empty we will get this in query string:
    *
@@ -270,14 +269,14 @@ interface QueryHandlerBaseOptions extends QueryHandlerSharedOptions {
 }
 interface RegisterQueryHandlerBaseOptions<T> extends QueryHandlerSharedOptions {
   /**
-   * Prefix in query string.
+   * Key in query string.
    *
    * @example
    * ```
    * filters, table-1[filters], table-2[filters]
    * ```
    */
-  prefix?: string;
+  key?: string;
   /**
    * Transform function to convert deserialized query parameters to the expected type.
    *
@@ -298,8 +297,8 @@ interface RegisterQueryHandlerBaseOptions<T> extends QueryHandlerSharedOptions {
    * ```ts
    * const data = ref({ page: undefined as number | undefined })
    *
-   * useContextStorageQueryHandler(data, {
-   *   prefix: 'filters',
+   * useContextStorage('query', data, {
+   *   key: 'filters',
    *   onlyChanges: true,
    *   additionalDefaultData: { page: 1 },
    * })
@@ -325,11 +324,6 @@ interface WebStorageHandlerBaseOptions {
 }
 interface RegisterWebStorageHandlerBaseOptions<T> {
   key?: string;
-  /**
-   * Optional prefix for nested data within the storage key.
-   * When provided, data will be stored under this prefix within the main storage object.
-   */
-  prefix?: string;
   /**
    * Transform function to convert deserialized storage data to the expected type.
    *
@@ -365,7 +359,10 @@ interface ContextStorageHandlerMap<T> {
   localStorage: RegisterWebStorageHandlerOptions<T>;
   sessionStorage: RegisterWebStorageHandlerOptions<T>;
 }
-declare function defineContextStorageHandler<T, O extends object>(name: string, injectionKey: InjectionKey<ContextStorageHandler<T, O>>): void;
+declare function defineContextStorageHandler<T, O extends object>(name: string, injectionKey: InjectionKey<ContextStorageHandler<T, O>>, options?: {
+  prefixProperty?: string;
+  prefixMergeStrategy?: 'prepend' | 'append';
+}): void;
 declare function resolveHandlerInjectionKey<K$1 extends keyof ContextStorageHandlerMap<T>, T>(type: K$1): InjectionKey<ContextStorageHandler<T, ContextStorageHandlerMap<T>[K$1]>> | undefined;
 //#endregion
 //#region src/composables/types.d.ts
@@ -401,16 +398,13 @@ declare function useContextStorageCollection(handlers?: ContextStorageHandlerFac
 declare function useContextStorageProvider(key: string): void;
 //#endregion
 //#region src/handlers/query/index.d.ts
-declare function useContextStorageQueryHandler<T extends Record<string, unknown>>(data: MaybeRefOrGetter<T>, options?: RegisterQueryHandlerOptions<T>): UseContextStorageResult<T>;
 declare function createQueryHandler(baseOptions?: QueryHandlerBaseOptions): ContextStorageHandlerFactory;
 //#endregion
 //#region src/handlers/local-storage/index.d.ts
 declare function createLocalStorageHandler(customOptions?: WebStorageHandlerBaseOptions): ContextStorageHandlerFactory;
-declare const useContextStorageLocalStorage: (data: vue9.MaybeRefOrGetter<Record<string, unknown>>, options: RegisterWebStorageHandlerOptions<Record<string, unknown>>) => UseContextStorageResult<Record<string, unknown>>;
 //#endregion
 //#region src/handlers/session-storage/index.d.ts
 declare function createSessionStorageHandler(customOptions?: WebStorageHandlerBaseOptions): ContextStorageHandlerFactory;
-declare const useContextStorageSessionStorage: (data: vue9.MaybeRefOrGetter<Record<string, unknown>>, options: RegisterWebStorageHandlerOptions<Record<string, unknown>>) => UseContextStorageResult<Record<string, unknown>>;
 //#endregion
 //#region src/handlers/query/transform-helpers.d.ts
 declare function asNumber(value: QueryValue | number | undefined): number;
@@ -562,13 +556,13 @@ declare const transform: {
 //#region src/handlers/query/helpers.d.ts
 interface SerializeOptions {
   /**
-   * Custom prefix for serialized keys.
+   * Custom key prefix for serialized keys.
    * @example
-   * - prefix: 'filters' => 'filters[key]'
-   * - prefix: 'search' => 'search[key]'
-   * - prefix: '' => 'key' (no prefix)
+   * - key: 'filters' => 'filters[field]'
+   * - key: 'search' => 'search[field]'
+   * - key: '' => 'field' (no prefix)
    */
-  prefix?: string;
+  key?: string;
 }
 /**
  * Serializes filter parameters into a URL-friendly format.
@@ -616,4 +610,4 @@ declare const contextStorageSessionStorageHandlerInjectKey: InjectionKey<Context
 //#region src/constants.d.ts
 declare const defaultHandlers: ContextStorageHandlerFactory[];
 //#endregion
-export { type CollectionManager, type CollectionManagerItem, _default as ContextStorage, _default$1 as ContextStorageActivator, _default$2 as ContextStorageCollection, type ContextStorageHandler, type ContextStorageHandlerFactory, type ContextStorageHandlerMap, _default$3 as ContextStoragePrefix, type ContextStoragePrefixSegment, _default$4 as ContextStorageProvider, type WebStorageHandlerBaseOptions as LocalStorageHandlerBaseOptions, type QueryValue, type RegisterBaseOptions, type RegisterWebStorageHandlerBaseOptions as RegisterLocalStorageHandlerBaseOptions, VueContextStoragePlugin, asArray, asBoolean, asNumber, asNumberArray, asObjectArray, asString, contextStorageCollectionInjectKey, contextStorageCollectionItemInjectKey, contextStorageHandlersInjectKey, contextStorageLocalStorageHandlerInjectKey, contextStoragePrefixSegmentsInjectKey, contextStorageQueryHandlerInjectKey, contextStorageSessionStorageHandlerInjectKey, createCollectionManager, createLocalStorageHandler, createQueryHandler, createSessionStorageHandler, defaultHandlers, defineContextStorageHandler, deserializeParams as deserializeQueryParams, resolveHandlerInjectionKey, serializeParams as serializeQueryParams, transform, useContextStorage, useContextStorageActivator, useContextStorageCollection, useContextStorageLocalStorage, useContextStorageProvider, useContextStorageQueryHandler, useContextStorageSessionStorage };
+export { type CollectionManager, type CollectionManagerItem, _default as ContextStorage, _default$1 as ContextStorageActivator, _default$2 as ContextStorageCollection, type ContextStorageHandler, type ContextStorageHandlerFactory, type ContextStorageHandlerMap, _default$3 as ContextStoragePrefix, type ContextStoragePrefixSegment, _default$4 as ContextStorageProvider, type WebStorageHandlerBaseOptions as LocalStorageHandlerBaseOptions, type QueryValue, type RegisterBaseOptions, type RegisterWebStorageHandlerBaseOptions as RegisterLocalStorageHandlerBaseOptions, VueContextStoragePlugin, asArray, asBoolean, asNumber, asNumberArray, asObjectArray, asString, contextStorageCollectionInjectKey, contextStorageCollectionItemInjectKey, contextStorageHandlersInjectKey, contextStorageLocalStorageHandlerInjectKey, contextStoragePrefixSegmentsInjectKey, contextStorageQueryHandlerInjectKey, contextStorageSessionStorageHandlerInjectKey, createCollectionManager, createLocalStorageHandler, createQueryHandler, createSessionStorageHandler, defaultHandlers, defineContextStorageHandler, deserializeParams as deserializeQueryParams, resolveHandlerInjectionKey, serializeParams as serializeQueryParams, transform, useContextStorage, useContextStorageActivator, useContextStorageCollection, useContextStorageProvider };

package/dist/index.js

@@ -19,8 +19,7 @@ function joinPrefix(left, right) {
 	return `${left}[${right}]`;
 }
 const contextStoragePrefixSegmentsInjectKey = contextStoragePrefixSegments;
-function resolvePrefixSegments(segments, handlerInjectionKey, knownHandlerKeys$1) {
-	const handlerType = knownHandlerKeys$1.get(handlerInjectionKey);
+function resolvePrefixSegments(segments, handlerType) {
 	let combined = "";
 	for (const segment of segments) {
 		let value;
@@ -62,7 +61,7 @@ var ContextStorageActivator_default = ContextStorageActivator_vue_vue_type_scrip
 //#endregion
 //#region src/handlers/query/helpers.ts
 function serializeParams(params, options = {}) {
-	const { prefix = "" } = options;
+	const { key: prefix = "" } = options;
 	const result = {};
 	Object.keys(params).forEach((key) => {
 		const value = params[key];
@@ -80,12 +79,12 @@ function serializeParams(params, options = {}) {
 			});
 			Object.assign(result, serializeParams(indexed, {
 				...options,
-				prefix: formattedKey
+				key: formattedKey
 			}));
 		} else result[formattedKey] = value.map(String);
 		else Object.assign(result, serializeParams(value, {
 			...options,
-			prefix: formattedKey
+			key: formattedKey
 		}));
 		else if (typeof value === "boolean") result[formattedKey] = value ? "1" : "0";
 		else result[formattedKey] = String(value);
@@ -145,8 +144,17 @@ function applyTransform(input) {
 	};
 }
 const knownHandlerKeys = /* @__PURE__ */ new Map();
-function registerKnownHandlerKey(injectionKey, handlerType) {
-	knownHandlerKeys.set(injectionKey, handlerType);
+function registerKnownHandlerKey(injectionKey, handlerType, prefixProperty = "key", prefixMergeStrategy = "prepend") {
+	knownHandlerKeys.set(injectionKey, {
+		handlerType,
+		prefixProperty,
+		prefixMergeStrategy
+	});
+}
+function appendBracketNotation(base, suffix) {
+	const bracketIdx = suffix.indexOf("[");
+	if (bracketIdx === -1) return `${base}[${suffix}]`;
+	return `${base}[${suffix.slice(0, bracketIdx)}]${suffix.slice(bracketIdx)}`;
 }
 function buildContextStorageHandler(handler, data, options) {
 	const uid = getCurrentInstance()?.uid || 0;
@@ -158,11 +166,16 @@ function buildContextStorageHandler(handler, data, options) {
 	const rawPrefixSegments = inject(contextStoragePrefixSegmentsInjectKey, void 0);
 	const prefixSegments = rawPrefixSegments ? toValue(rawPrefixSegments) : void 0;
 	if (prefixSegments && prefixSegments.length > 0) {
-		const resolvedPrefix = resolvePrefixSegments(prefixSegments, handler.getInjectionKey(), knownHandlerKeys);
+		const handlerInjectionKey = handler.getInjectionKey();
+		const handlerInfo = knownHandlerKeys.get(handlerInjectionKey);
+		const resolvedPrefix = resolvePrefixSegments(prefixSegments, handlerInfo?.handlerType);
 		if (resolvedPrefix) {
-			const optionsPrefix = mergedOptions.prefix;
-			if (optionsPrefix) mergedOptions.prefix = `${resolvedPrefix}[${optionsPrefix}]`;
-			else mergedOptions.prefix = resolvedPrefix;
+			const prefixProp = handlerInfo?.prefixProperty ?? "key";
+			const strategy = handlerInfo?.prefixMergeStrategy ?? "prepend";
+			const optionsValue = mergedOptions[prefixProp];
+			if (optionsValue) if (strategy === "append") mergedOptions[prefixProp] = appendBracketNotation(optionsValue, resolvedPrefix);
+			else mergedOptions[prefixProp] = `${resolvedPrefix}[${optionsValue}]`;
+			else mergedOptions[prefixProp] = resolvedPrefix;
 		}
 	}
 	const { stop, reset, wasChanged } = handler.register(data, mergedOptions);
@@ -199,23 +212,23 @@ function buildQuery(input) {
 	const warnings = [];
 	const newQueryRaw = {};
 	input.items.forEach((item) => {
-		const { prefix, onlyChanges = input.onlyChanges } = item;
+		const { key, onlyChanges = input.onlyChanges } = item;
 		let preserveEmptyState = item.preserveEmptyState ?? input.preserveEmptyState;
-		const patch = serializeParams(item.data, { prefix });
+		const patch = serializeParams(item.data, { key });
 		if (onlyChanges) {
 			if (preserveEmptyState) {
 				preserveEmptyState = false;
 				warnings.push("[vue-context-storage] preserveEmptyState is not supported with onlyChanges");
 			}
-			Object.keys(patch).forEach((key) => {
-				if (isEqual(patch[key], item.initialQueryData[key]) || item.additionalDefaultQueryData && isEqual(patch[key], item.additionalDefaultQueryData[key])) delete patch[key];
+			Object.keys(patch).forEach((key2) => {
+				if (isEqual(patch[key2], item.initialQueryData[key2]) || item.additionalDefaultQueryData && isEqual(patch[key2], item.additionalDefaultQueryData[key2])) delete patch[key2];
 			});
 		}
 		const patchKeys = Object.keys(patch);
-		patchKeys.forEach((key) => {
-			if (Object.hasOwn(newQueryRaw, key)) warnings.push(`[vue-context-storage] Key ${key} is already present, overriding ` + (item.causer || ""));
+		patchKeys.forEach((key2) => {
+			if (Object.hasOwn(newQueryRaw, key2)) warnings.push(`[vue-context-storage] Key ${key2} is already present, overriding ` + (item.causer || ""));
 		});
-		if (!patchKeys.length && preserveEmptyState) patch[prefix || input.emptyPlaceholder] = null;
+		if (!patchKeys.length && preserveEmptyState) patch[key || input.emptyPlaceholder] = null;
 		Object.assign(newQueryRaw, patch);
 	});
 	let newQuery = { ...newQueryRaw };
@@ -239,8 +252,8 @@ function buildQuery(input) {
 //#region src/handlers/query/compute-sync-state.ts
 function computeSyncState(input) {
 	let state = input.deserializedState;
-	if (typeof input.prefix === "string" && input.prefix.length > 0) {
-		const parts = input.prefix.split(/[\[\]]/).filter(Boolean);
+	if (typeof input.key === "string" && input.key.length > 0) {
+		const parts = input.key.split(/[\[\]]/).filter(Boolean);
 		for (const part of parts) {
 			if (state === void 0 || state === null) break;
 			state = state[part];
@@ -262,11 +275,6 @@ function computeSyncState(input) {
 
 //#endregion
 //#region src/handlers/query/index.ts
-function useContextStorageQueryHandler(data, options) {
-	const handler = inject(contextStorageQueryHandler);
-	if (!handler) throw new Error("[vue-context-storage] ContextStorageQueryHandler is not provided");
-	return buildContextStorageHandler(handler, data, options);
-}
 function createQueryHandler(baseOptions) {
 	const factory = () => {
 		const route = useRoute();
@@ -358,13 +366,13 @@ function createQueryHandler(baseOptions) {
 			registered.forEach((item) => syncInitialStateToRegisteredItem(item));
 		}
 		function syncInitialStateToRegisteredItem(item) {
-			const prefix = item.options?.prefix;
+			const key = item.options?.key;
 			const { mergeOnlyExistingKeysWithoutTransform = options.mergeOnlyExistingKeysWithoutTransform } = item.options || {};
 			const itemState = toValue(item.data);
 			const result = computeSyncState({
 				deserializedState: deserializeParams(route.query),
 				initialData: item.initialData,
-				prefix,
+				key,
 				emptyPlaceholder: options.emptyPlaceholder
 			});
 			if (result.type === "none") return;
@@ -383,45 +391,45 @@ function createQueryHandler(baseOptions) {
 			});
 			transformed.warnings.forEach((w) => console.warn(w.message, ...w.args));
 			const finalData = { ...transformed.data };
-			for (const key of Object.keys(itemState)) if (!urlKeys.has(key)) finalData[key] = itemState[key];
+			for (const key2 of Object.keys(itemState)) if (!urlKeys.has(key2)) finalData[key2] = itemState[key2];
 			if (isEqual(itemState, finalData)) return;
 			({ ...itemState });
 			syncReactive(itemState, finalData);
 		}
 		function register(data, registerOptions) {
 			const resolvedData = toValue(data);
-			if (registeredDataObjects.has(resolvedData)) console.warn("[vue-context-storage] The same data object is already registered in ContextStorageQueryHandler.", { prefix: registerOptions?.prefix });
+			if (registeredDataObjects.has(resolvedData)) console.warn("[vue-context-storage] The same data object is already registered in ContextStorageQueryHandler.", { key: registerOptions?.key });
 			registeredDataObjects.add(resolvedData);
 			hasAnyRegistered = true;
 			const watchHandle = watch(data, () => {
-				registerOptions.prefix;
+				registerOptions.key;
 				scheduleSyncToQuery();
 			}, { deep: true });
 			const initialData = cloneDeep(resolvedData);
 			const item = {
 				data,
 				initialData,
-				initialQueryData: serializeParams(initialData, { prefix: registerOptions.prefix }),
-				additionalDefaultQueryData: registerOptions.additionalDefaultData ? serializeParams(registerOptions.additionalDefaultData, { prefix: registerOptions.prefix }) : void 0,
+				initialQueryData: serializeParams(initialData, { key: registerOptions.key }),
+				additionalDefaultQueryData: registerOptions.additionalDefaultData ? serializeParams(registerOptions.additionalDefaultData, { key: registerOptions.key }) : void 0,
 				options: registerOptions,
 				watchHandle
 			};
 			registered.push(item);
 			const syncCallback = () => {
-				registerOptions.prefix;
+				registerOptions.key;
 				syncInitialStateToRegisteredItem(item);
 				scheduleSyncToQuery();
 			};
 			if (preventAfterEachRouteCallsWhileCallingRouter) {
-				registerOptions.prefix;
+				registerOptions.key;
 				setTimeout(syncCallback);
 			} else {
-				registerOptions.prefix;
+				registerOptions.key;
 				syncCallback();
 			}
 			return {
 				stop: () => {
-					registerOptions.prefix;
+					registerOptions.key;
 					item.watchHandle.stop();
 					const index = registered.indexOf(item);
 					if (index !== -1) registered.splice(index, 1);
@@ -430,7 +438,7 @@ function createQueryHandler(baseOptions) {
 					currentQuery = void 0;
 				},
 				reset: () => {
-					registerOptions.prefix;
+					registerOptions.key;
 					syncReactive(toValue(data), cloneDeep(initialData));
 				},
 				wasChanged: computed(() => !isEqual(toValue(data), initialData))
@@ -442,7 +450,7 @@ function createQueryHandler(baseOptions) {
 					data: toValue(item.data),
 					initialQueryData: item.initialQueryData,
 					additionalDefaultQueryData: item.additionalDefaultQueryData,
-					prefix: item.options?.prefix,
+					key: item.options?.key,
 					onlyChanges: item.options?.onlyChanges,
 					preserveEmptyState: item.options?.preserveEmptyState,
 					causer: item.options?.causer
@@ -485,19 +493,10 @@ function createWebStorageHandlerInstance(config) {
 			window.removeEventListener("storage", handler);
 		});
 	}
-	function resolveStorageKey(key, prefix) {
-		if (prefix) {
-			const bracketIdx = prefix.indexOf("[");
-			if (bracketIdx === -1) return `${key}[${prefix}]`;
-			return `${key}[${prefix.slice(0, bracketIdx)}]${prefix.slice(bracketIdx)}`;
-		}
-		return key;
-	}
 	function handleStorageEvent(event) {
 		if (!enabled) return;
 		registered.forEach((item) => {
-			const effectiveKey = resolveStorageKey(item.options.key, item.options.prefix);
-			if (event.key === effectiveKey) syncStorageToRegisteredItem(item);
+			if (event.key === item.options.key) syncStorageToRegisteredItem(item);
 		});
 	}
 	function getInjectionKey() {
@@ -514,23 +513,23 @@ function createWebStorageHandlerInstance(config) {
 	function syncRegisteredToStorage() {
 		if (!enabled) return;
 		registered.forEach((item) => {
-			const effectiveKey = resolveStorageKey(item.options.key, item.options.prefix);
+			const storageKey = item.options.key;
 			const data = toValue(item.data);
 			const { serializer } = item.options;
 			try {
-				if (serializer) config.storage.setItem(effectiveKey, serializer(data));
-				else config.storage.setItem(effectiveKey, JSON.stringify(data));
+				if (serializer) config.storage.setItem(storageKey, serializer(data));
+				else config.storage.setItem(storageKey, JSON.stringify(data));
 			} catch (e) {
 				console.error("[vue-context-storage] Error writing to storage", e);
 			}
 		});
 	}
 	function syncStorageToRegisteredItem(item) {
-		const { key, prefix, deserializer } = item.options;
-		const effectiveKey = resolveStorageKey(key, prefix);
+		const { key, deserializer } = item.options;
+		const storageKey = key;
 		let stored = null;
 		try {
-			stored = config.storage.getItem(effectiveKey);
+			stored = config.storage.getItem(storageKey);
 		} catch {
 			return;
 		}
@@ -540,7 +539,7 @@ function createWebStorageHandlerInstance(config) {
 			if (deserializer) deserialized = deserializer(stored);
 			else deserialized = JSON.parse(stored);
 		} catch {
-			console.warn("[vue-context-storage] Failed to parse storage data for key:", effectiveKey);
+			console.warn("[vue-context-storage] Failed to parse storage data for key:", storageKey);
 			return;
 		}
 		if (deserialized === void 0 || deserialized === null) return;
@@ -562,10 +561,7 @@ function createWebStorageHandlerInstance(config) {
 	function register(data, options) {
 		if (!options.key) throw new Error("[vue-context-storage] Storage handler requires a key option");
 		const resolvedData = toValue(data);
-		if (registeredDataObjects.has(resolvedData)) console.warn(`[vue-context-storage] The same data object is already registered in ${config.handlerName}.`, {
-			key: options.key,
-			prefix: options.prefix
-		});
+		if (registeredDataObjects.has(resolvedData)) console.warn(`[vue-context-storage] The same data object is already registered in ${config.handlerName}.`, { key: options.key });
 		registeredDataObjects.add(resolvedData);
 		hasAnyRegistered = true;
 		const watchHandle = watch(data, () => syncRegisteredToStorage(), { deep: true });
@@ -597,13 +593,6 @@ function createWebStorageHandlerInstance(config) {
 		getInjectionKey
 	};
 }
-function createWebStorageComposable(injectionKey, handlerName) {
-	return function useContextStorageWebStorage(data, options) {
-		const handler = inject(injectionKey);
-		if (!handler) throw new Error(`[vue-context-storage] ${handlerName} is not provided`);
-		return buildContextStorageHandler(handler, data, options);
-	};
-}
 
 //#endregion
 //#region src/handlers/local-storage/index.ts
@@ -619,7 +608,6 @@ function createLocalStorageHandler(customOptions) {
 	});
 	return factory;
 }
-const useContextStorageLocalStorage = createWebStorageComposable(contextStorageLocalStorageHandler, "ContextStorageLocalStorageHandler");
 
 //#endregion
 //#region src/handlers/session-storage/index.ts
@@ -635,7 +623,6 @@ function createSessionStorageHandler(customOptions) {
 	});
 	return factory;
 }
-const useContextStorageSessionStorage = createWebStorageComposable(contextStorageSessionStorageHandler, "ContextStorageSessionStorageHandler");
 
 //#endregion
 //#region src/constants.ts
@@ -847,16 +834,22 @@ const VueContextStoragePlugin = { install(app) {
 //#endregion
 //#region src/registry.ts
 const handlerRegistry = /* @__PURE__ */ new Map();
-function defineContextStorageHandler(name, injectionKey) {
+function defineContextStorageHandler(name, injectionKey, options) {
 	handlerRegistry.set(name, injectionKey);
-	registerKnownHandlerKey(injectionKey, name);
+	registerKnownHandlerKey(injectionKey, name, options?.prefixProperty, options?.prefixMergeStrategy);
 }
 function resolveHandlerInjectionKey(type) {
 	return handlerRegistry.get(type);
 }
-defineContextStorageHandler("query", contextStorageQueryHandlerInjectKey);
-defineContextStorageHandler("localStorage", contextStorageLocalStorageHandlerInjectKey);
-defineContextStorageHandler("sessionStorage", contextStorageSessionStorageHandlerInjectKey);
+defineContextStorageHandler("query", contextStorageQueryHandlerInjectKey, { prefixProperty: "key" });
+defineContextStorageHandler("localStorage", contextStorageLocalStorageHandlerInjectKey, {
+	prefixProperty: "key",
+	prefixMergeStrategy: "append"
+});
+defineContextStorageHandler("sessionStorage", contextStorageSessionStorageHandlerInjectKey, {
+	prefixProperty: "key",
+	prefixMergeStrategy: "append"
+});
 
 //#endregion
 //#region src/composables/useContextStorage.ts
@@ -945,4 +938,4 @@ const transform = {
 };
 
 //#endregion
-export { ContextStorage_default as ContextStorage, ContextStorageActivator_default as ContextStorageActivator, ContextStorageCollection_default as ContextStorageCollection, ContextStoragePrefix_default as ContextStoragePrefix, ContextStorageProvider_default as ContextStorageProvider, VueContextStoragePlugin, asArray, asBoolean, asNumber, asNumberArray, asObjectArray, asString, contextStorageCollectionInjectKey, contextStorageCollectionItemInjectKey, contextStorageHandlersInjectKey, contextStorageLocalStorageHandlerInjectKey, contextStoragePrefixSegmentsInjectKey, contextStorageQueryHandlerInjectKey, contextStorageSessionStorageHandlerInjectKey, createCollectionManager, createLocalStorageHandler, createQueryHandler, createSessionStorageHandler, defaultHandlers, defineContextStorageHandler, deserializeParams as deserializeQueryParams, resolveHandlerInjectionKey, serializeParams as serializeQueryParams, transform, useContextStorage, useContextStorageActivator, useContextStorageCollection, useContextStorageLocalStorage, useContextStorageProvider, useContextStorageQueryHandler, useContextStorageSessionStorage };
+export { ContextStorage_default as ContextStorage, ContextStorageActivator_default as ContextStorageActivator, ContextStorageCollection_default as ContextStorageCollection, ContextStoragePrefix_default as ContextStoragePrefix, ContextStorageProvider_default as ContextStorageProvider, VueContextStoragePlugin, asArray, asBoolean, asNumber, asNumberArray, asObjectArray, asString, contextStorageCollectionInjectKey, contextStorageCollectionItemInjectKey, contextStorageHandlersInjectKey, contextStorageLocalStorageHandlerInjectKey, contextStoragePrefixSegmentsInjectKey, contextStorageQueryHandlerInjectKey, contextStorageSessionStorageHandlerInjectKey, createCollectionManager, createLocalStorageHandler, createQueryHandler, createSessionStorageHandler, defaultHandlers, defineContextStorageHandler, deserializeParams as deserializeQueryParams, resolveHandlerInjectionKey, serializeParams as serializeQueryParams, transform, useContextStorage, useContextStorageActivator, useContextStorageCollection, useContextStorageProvider };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vue-context-storage",
   "type": "module",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "Vue 3 context storage system with URL query synchronization support",
   "author": "",
   "license": "MIT",