vue-context-storage 0.1.8 → 0.1.10

package/dist/index.d.ts

@@ -1,10 +1,411 @@
-export type { ContextStorageHandler, ContextStorageHandlerConstructor, RegisterBaseOptions, } from './handlers';
-export { ContextStorageQueryHandler, useContextStorageQueryHandler } from './handlers/query';
-export { deserializeParams, serializeParams } from './handlers/query/helpers';
-export type { SerializeOptions } from './handlers/query/helpers';
-export { asArray, asBoolean, asNumber, asNumberArray, asString, transform, } from './handlers/query/transform-helpers';
-export { contextStorageCollectionInjectKey, contextStorageCollectionItemInjectKey, contextStorageHandlersInjectKey, contextStorageQueryHandlerInjectKey, } from './injectionSymbols';
-export { collection, collectionItem, contextStorageQueryHandler, handlers } from './symbols';
-export { defaultHandlers } from './constants';
-export type { QueryValue, IContextStorageQueryHandler } from './handlers/query/types';
-export type { ContextStorageCollectionItem } from './collection';
+import * as vue0 from "vue";
+import { InjectionKey, MaybeRefOrGetter, PropType, UnwrapNestedRefs, WatchHandle } from "vue";
+import { LocationQuery, LocationQueryValue } from "vue-router";
+
+//#region src/components/ContextStorageActivator.vue.d.ts
+declare const _default$1: typeof __VLS_export$3;
+declare const __VLS_export$3: vue0.DefineComponent<{}, () => vue0.VNode<vue0.RendererNode, vue0.RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, vue0.ComponentOptionsMixin, vue0.ComponentOptionsMixin, {}, string, vue0.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue0.ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/handlers.d.ts
+interface ContextStorageHandlerConstructor {
+  new (): ContextStorageHandler;
+  getInitialStateResolver?: () => () => Record<string, unknown>;
+}
+interface RegisterBaseOptions {
+  causer: string;
+  uid: number;
+}
+interface ContextStorageHandler {
+  register: (data: MaybeRefOrGetter, options: RegisterBaseOptions) => () => void;
+  setInitialState?: (state: Record<string, unknown>) => void;
+  setEnabled?: (enabled: boolean, initial: boolean) => void;
+  getInjectionKey(): InjectionKey<ContextStorageHandler>;
+}
+//#endregion
+//#region src/components/ContextStorageCollection.vue.d.ts
+declare const _default$2: typeof __VLS_export$2;
+declare const __VLS_export$2: vue0.DefineComponent<vue0.ExtractPropTypes<{
+  handlers: {
+    type: PropType<ContextStorageHandlerConstructor[]>;
+    default: () => ContextStorageHandlerConstructor[];
+  };
+}>, () => vue0.VNode<vue0.RendererNode, vue0.RendererElement, {
+  [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue0.ComponentOptionsMixin, vue0.ComponentOptionsMixin, {}, string, vue0.PublicProps, Readonly<vue0.ExtractPropTypes<{
+  handlers: {
+    type: PropType<ContextStorageHandlerConstructor[]>;
+    default: () => ContextStorageHandlerConstructor[];
+  };
+}>> & Readonly<{}>, {
+  handlers: ContextStorageHandlerConstructor[];
+}, {}, {}, {}, string, vue0.ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/ContextStorageProvider.vue.d.ts
+declare const _default$3: typeof __VLS_export$1;
+declare const __VLS_export$1: vue0.DefineComponent<vue0.ExtractPropTypes<{
+  itemKey: {
+    type: StringConstructor;
+    required: true;
+  };
+}>, () => vue0.VNode<vue0.RendererNode, vue0.RendererElement, {
+  [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue0.ComponentOptionsMixin, vue0.ComponentOptionsMixin, {}, string, vue0.PublicProps, Readonly<vue0.ExtractPropTypes<{
+  itemKey: {
+    type: StringConstructor;
+    required: true;
+  };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue0.ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/ContextStorage.vue.d.ts
+interface Props {
+  handlers: ContextStorageHandlerConstructor[];
+}
+declare var __VLS_20: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_20) => any;
+};
+declare const __VLS_base: vue0.DefineComponent<Props, {}, {}, {}, {}, vue0.ComponentOptionsMixin, vue0.ComponentOptionsMixin, {}, string, vue0.PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, vue0.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/symbols.d.ts
+declare const collection: unique symbol;
+declare const collectionItem: unique symbol;
+declare const handlers: unique symbol;
+declare const contextStorageQueryHandler: unique symbol;
+//#endregion
+//#region src/handlers/query/types.d.ts
+type QueryValue = LocationQueryValue | LocationQueryValue[];
+type DeepTransformValuesToLocationQueryValue<T> = { [K in keyof T]?: T[K] extends object ? T[K] extends Array<any> ? QueryValue : DeepTransformValuesToLocationQueryValue<T[K]> : QueryValue };
+interface QueryHandlerSharedOptions {
+  /**
+   * Default: false
+   *
+   * If enabled - empty state will be preserved in query.
+   *
+   * Useful, when you have default values, and want to preserve empty state in query.
+   * @example
+   * ```
+   * Options: {preserveEmptyState: true, prefix: 'filters'}
+   *
+   * When filters are empty we will get this in query string:
+   *
+   * /list?filters
+   *
+   * After page reload state will be not restored to default
+   * ```
+   *
+   * @example
+   * ```
+   * Options: {preserveEmptyState: false, prefix: 'filters'}
+   *
+   * When filters are empty we will get this in query string:
+   *
+   * /list
+   *
+   * After page reload state will be restored to default
+   * ```
+   *
+   * @example
+   * ```
+   * Options: {preserveEmptyState: true}
+   *
+   * When filters are empty we will get this in query string:
+   *
+   * /list?_
+   *
+   * After page reload state will be not restored to default.
+   * Underscore (_) is default value for emptyPlaceholder option
+   * ```
+   */
+  preserveEmptyState?: boolean;
+  /**
+   * Default: true
+   *
+   * If transform option is not passed, ref will be merged with query only by keys that exists in ref.
+   */
+  mergeOnlyExistingKeysWithoutTransform?: boolean;
+}
+interface QueryHandlerBaseOptions extends QueryHandlerSharedOptions {
+  /**
+   * Default: replace
+   *
+   * Vue-router navigate mode.
+   * Use push if you want to add new query to history.
+   * Use replace if you want to replace current query without adding to history.
+   */
+  mode?: 'replace' | 'push';
+  /**
+   * Default: _
+   *
+   * Placeholder for empty state, used when preserveEmptyState is true and all ref values are empty.
+   */
+  emptyPlaceholder?: string;
+  /**
+   * Default: false
+   *
+   * If enabled - unused keys will be preserved in query.
+   * Unused keys are keys, that are not exists in ref.
+   */
+  preserveUnusedKeys?: boolean;
+}
+interface RegisterQueryHandlerBaseOptions<T> extends QueryHandlerSharedOptions {
+  /**
+   * Prefix in query string.
+   *
+   * @example
+   * ```
+   * filters, table-1[filters], table-2[filters]
+   * ```
+   */
+  prefix?: string;
+  transform?: (deserialized: DeepTransformValuesToLocationQueryValue<UnwrapNestedRefs<T>>, initialData: T) => UnwrapNestedRefs<T>;
+}
+interface RegisterQueryHandlerOptions<T> extends RegisterBaseOptions, RegisterQueryHandlerBaseOptions<T> {}
+interface IContextStorageQueryHandler extends ContextStorageHandler {
+  register: <T extends Record<string, unknown>>(data: MaybeRefOrGetter<T>, options: RegisterQueryHandlerOptions<T>) => () => void;
+}
+interface ContextStorageQueryRegisteredItem<T extends Record<string, unknown>> {
+  data: MaybeRefOrGetter<T>;
+  initialData: T;
+  options: RegisterQueryHandlerOptions<T>;
+  watchHandle: WatchHandle;
+}
+//#endregion
+//#region src/handlers/query/index.d.ts
+declare function useContextStorageQueryHandler<T extends Record<string, unknown>>(data: MaybeRefOrGetter<T>, options?: RegisterQueryHandlerBaseOptions<T>): void;
+declare class ContextStorageQueryHandler implements IContextStorageQueryHandler {
+  #private;
+  private enabled;
+  private registered;
+  private currentQuery;
+  private readonly route;
+  private router;
+  private initialState?;
+  private hasAnyRegistered;
+  private preventSyncRegisteredToQueryByAfterEachRoute;
+  private preventAfterEachRouteCallsWhileCallingRouter;
+  static customQueryHandlerOptions: QueryHandlerBaseOptions;
+  private readonly options;
+  static configure(options: QueryHandlerBaseOptions): ContextStorageHandlerConstructor;
+  constructor();
+  getInjectionKey(): typeof contextStorageQueryHandler;
+  setInitialState(state: Record<string, unknown> | undefined): void;
+  static getInitialStateResolver(): () => LocationQuery;
+  setEnabled(state: boolean, initial: boolean): void;
+  syncRegisteredToQuery(): Promise<void>;
+  afterEachRoute(): void;
+  syncInitialStateToRegisteredItem<T extends Record<string, unknown>>(item: ContextStorageQueryRegisteredItem<T>): void;
+  syncInitialStateToRegistered(): void;
+  register<T extends Record<string, unknown>>(data: MaybeRefOrGetter<T>, options: RegisterQueryHandlerOptions<T>): () => void;
+}
+//#endregion
+//#region src/handlers/query/helpers.d.ts
+interface SerializeOptions {
+  /**
+   * Custom prefix for serialized keys.
+   * @example
+   * - prefix: 'filters' => 'filters[key]'
+   * - prefix: 'search' => 'search[key]'
+   * - prefix: '' => 'key' (no prefix)
+   */
+  prefix?: string;
+}
+/**
+ * Serializes filter parameters into a URL-friendly format.
+ *
+ * @param params - Raw parameters object to serialize
+ * @param options - Serialization options
+ * @returns Serialized parameters with prefixed keys
+ *
+ * @example
+ * // With default prefix 'filters'
+ * serializeFiltersParams({ status: 'active', tags: ['a', 'b'] })
+ * // => { 'filters[status]': 'active', 'filters[tags]': 'a,b' }
+ *
+ * @example
+ * // With custom prefix
+ * serializeFiltersParams({ name: 'John', all: true }, { prefix: 'search' })
+ * // => { 'search[name]': 'John', 'search[all]': '1' }
+ *
+ * @example
+ * // Without prefix
+ * serializeFiltersParams({ page: 1, all: false }, { prefix: '' })
+ * // => { 'page': '1', 'all': '0' }
+ */
+declare function serializeParams(params: Record<string, unknown>, options?: SerializeOptions): LocationQuery;
+/**
+ * Deserializes query parameters from a URL-friendly format back to an object.
+ *
+ * @param params - Serialized parameters object
+ * @returns Deserialized parameters object
+ *
+ * @example
+ * deserializeParams({ 'filters[status]': 'active', search: 'test' })
+ * // => { filters: {status: 'active'}, search: 'test' }
+ */
+declare function deserializeParams(params: Record<string, any>): Record<string, any>;
+//#endregion
+//#region src/handlers/query/transform-helpers.d.ts
+declare function asNumber(value: QueryValue | number | undefined): number;
+declare function asNumber(value: QueryValue | number | undefined, options: {
+  nullable: true;
+  missable: true;
+  fallbackValue?: number;
+}): number | null | undefined;
+declare function asNumber(value: QueryValue | number | undefined, options: {
+  nullable: true;
+  missable?: false;
+  fallbackValue?: number;
+}): number | null;
+declare function asNumber(value: QueryValue | number | undefined, options: {
+  nullable?: false;
+  missable: true;
+  fallbackValue?: number;
+}): number | undefined;
+declare function asNumber(value: QueryValue | number | undefined, options: {
+  nullable?: false;
+  missable?: false;
+  fallbackValue?: number;
+}): number;
+declare function asString(value: QueryValue | undefined): string;
+declare function asString<T extends readonly string[]>(value: QueryValue | undefined, options: {
+  nullable: true;
+  missable: true;
+  fallbackValue?: T[number];
+  allowedValues: T;
+}): T[number] | null | undefined;
+declare function asString<T extends readonly string[]>(value: QueryValue | undefined, options: {
+  nullable: true;
+  missable?: false;
+  fallbackValue?: T[number];
+  allowedValues: T;
+}): T[number] | null;
+declare function asString<T extends readonly string[]>(value: QueryValue | undefined, options: {
+  nullable?: false;
+  missable: true;
+  fallbackValue?: T[number];
+  allowedValues: T;
+}): T[number] | undefined;
+declare function asString<T extends readonly string[]>(value: QueryValue | undefined, options: {
+  nullable?: false;
+  missable?: false;
+  fallbackValue?: T[number];
+  allowedValues: T;
+}): T[number];
+declare function asString(value: QueryValue | undefined, options: {
+  nullable: true;
+  missable: true;
+  fallbackValue?: string;
+}): string | null | undefined;
+declare function asString(value: QueryValue | undefined, options: {
+  nullable: true;
+  missable?: false;
+  fallbackValue?: string;
+}): string | null;
+declare function asString(value: QueryValue | undefined, options: {
+  nullable?: false;
+  missable: true;
+  fallbackValue?: string;
+}): string | undefined;
+declare function asString(value: QueryValue | undefined, options: {
+  nullable?: false;
+  missable?: false;
+  fallbackValue?: string;
+}): string;
+declare function asNumberArray(value: QueryValue | undefined): number[];
+declare function asNumberArray(value: QueryValue | undefined, options: {
+  nullable: true;
+}): number[] | null;
+declare function asNumberArray(value: QueryValue | undefined, options: {
+  nullable?: false;
+}): number[];
+declare function asArray<T>(value: QueryValue | undefined): T[];
+declare function asArray<T>(value: QueryValue | undefined, options: {
+  nullable: true;
+  missable: true;
+  transform?: (value: QueryValue) => T;
+}): T[] | null | undefined;
+declare function asArray<T>(value: QueryValue | undefined, options: {
+  nullable: true;
+  missable?: false;
+  transform?: (value: QueryValue) => T;
+}): T[] | null;
+declare function asArray<T>(value: QueryValue | undefined, options: {
+  nullable?: false;
+  missable: true;
+  transform?: (value: QueryValue) => T;
+}): T[] | undefined;
+declare function asArray<T>(value: QueryValue | undefined, options: {
+  nullable?: false;
+  missable?: false;
+  transform?: (value: QueryValue) => T;
+}): T[];
+declare function asBoolean(value: QueryValue | undefined): boolean;
+declare function asBoolean(value: QueryValue | undefined, options: {
+  nullable: true;
+  missable: true;
+  fallbackValue?: boolean;
+}): boolean | null | undefined;
+declare function asBoolean(value: QueryValue | undefined, options: {
+  nullable: true;
+  missable?: false;
+  fallbackValue?: boolean;
+}): boolean | null;
+declare function asBoolean(value: QueryValue | undefined, options: {
+  nullable?: false;
+  missable: true;
+  fallbackValue?: boolean;
+}): boolean | undefined;
+declare function asBoolean(value: QueryValue | undefined, options: {
+  nullable?: false;
+  missable?: false;
+  fallbackValue?: boolean;
+}): boolean;
+declare const transform: {
+  asString: typeof asString;
+  asNumber: typeof asNumber;
+  asArray: typeof asArray;
+  asNumberArray: typeof asNumberArray;
+  asBoolean: typeof asBoolean;
+};
+//#endregion
+//#region src/collection.d.ts
+type ContextStorageCollectionItem = {
+  key: string;
+  handlers: ContextStorageHandler[];
+};
+interface ItemOptions {
+  key: string;
+}
+declare class ContextStorageCollection {
+  private handlerConstructors;
+  active?: ContextStorageCollectionItem;
+  private collection;
+  private onActiveChangeCallbacks;
+  constructor(handlerConstructors: ContextStorageHandlerConstructor[]);
+  onActiveChange(callback: (item: ContextStorageCollectionItem) => void): void;
+  first(): ContextStorageCollectionItem | undefined;
+  findItemByKey(key: string): ContextStorageCollectionItem | undefined;
+  add(options: ItemOptions): ContextStorageCollectionItem;
+  remove(removeItem: ContextStorageCollectionItem): void;
+  setActive(activeItem: ContextStorageCollectionItem): void;
+}
+//#endregion
+//#region src/injectionSymbols.d.ts
+declare const contextStorageCollectionInjectKey: InjectionKey<ContextStorageCollection>;
+declare const contextStorageCollectionItemInjectKey: InjectionKey<ContextStorageCollectionItem>;
+declare const contextStorageHandlersInjectKey: InjectionKey<ContextStorageCollectionItem['handlers']>;
+declare const contextStorageQueryHandlerInjectKey: InjectionKey<InstanceType<typeof ContextStorageQueryHandler>>;
+//#endregion
+//#region src/constants.d.ts
+declare const defaultHandlers: ContextStorageHandlerConstructor[];
+//#endregion
+export { _default as ContextStorage, _default$1 as ContextStorageActivator, _default$2 as ContextStorageCollection, type ContextStorageHandler, type ContextStorageHandlerConstructor, _default$3 as ContextStorageProvider, ContextStorageQueryHandler, type IContextStorageQueryHandler, type QueryValue, type RegisterBaseOptions, type SerializeOptions, asArray, asBoolean, asNumber, asNumberArray, asString, collection, collectionItem, contextStorageCollectionInjectKey, contextStorageCollectionItemInjectKey, contextStorageHandlersInjectKey, contextStorageQueryHandler, contextStorageQueryHandlerInjectKey, defaultHandlers, deserializeParams, handlers, serializeParams, transform, useContextStorageQueryHandler };

package/dist/index.js

@@ -1,7 +1,51 @@
-import { cloneDeep, isEqual, merge, pick } from "lodash-es";
-import { getCurrentInstance, inject, onBeforeUnmount, toValue, watch } from "vue";
+import { computed, createBlock, createVNode, defineComponent, getCurrentInstance, h, inject, onBeforeUnmount, onUnmounted, openBlock, provide, renderSlot, toValue, watch, withCtx } from "vue";
+import { cloneDeep, isEqual, merge, pick } from "lodash";
 import { useRoute, useRouter } from "vue-router";
 
+//#region src/collection.ts
+var ContextStorageCollection = class {
+	active = void 0;
+	collection = [];
+	onActiveChangeCallbacks = [];
+	constructor(handlerConstructors) {
+		this.handlerConstructors = handlerConstructors;
+	}
+	onActiveChange(callback) {
+		this.onActiveChangeCallbacks.push(callback);
+	}
+	first() {
+		return this.collection[0];
+	}
+	findItemByKey(key) {
+		return this.collection.find((item) => item.key === key);
+	}
+	add(options) {
+		const item = {
+			handlers: this.handlerConstructors.map((constructor) => new constructor()),
+			key: options.key
+		};
+		this.collection.push(item);
+		return item;
+	}
+	remove(removeItem) {
+		if (this.collection.indexOf(removeItem) === -1) throw new Error("[ContextStorage] Item not found in collection");
+		this.collection = this.collection.filter((item) => item !== removeItem);
+		if (this.active === removeItem && this.collection.length > 0) this.setActive(this.collection[this.collection.length - 1]);
+	}
+	setActive(activeItem) {
+		if (this.active === activeItem) return;
+		const hasActiveBefore = this.active !== void 0;
+		this.active = activeItem;
+		this.collection.forEach((item) => {
+			Object.values(item.handlers).forEach((handler) => {
+				if (handler.setEnabled) handler.setEnabled(item === activeItem, !hasActiveBefore);
+			});
+		});
+		this.onActiveChangeCallbacks.forEach((callback) => callback(activeItem));
+	}
+};
+
+//#endregion
 //#region src/handlers/query/helpers.ts
 /**
 * Serializes filter parameters into a URL-friendly format.
@@ -87,9 +131,8 @@ const contextStorageQueryHandler = Symbol("context-storage-query-handler");
 function useContextStorageQueryHandler(data, options) {
 	const handler = inject(contextStorageQueryHandler);
 	if (!handler) throw new Error("[ContextStorage] ContextStorageQueryHandler is not provided");
-	const currentInstance = getCurrentInstance();
-	const uid = currentInstance?.uid || 0;
-	const causer = new Error().stack?.split("\n")[2]?.trimStart() || "unknown";
+	const uid = getCurrentInstance()?.uid || 0;
+	const causer = (/* @__PURE__ */ new Error()).stack?.split("\n")[2]?.trimStart() || "unknown";
 	const stop = handler.register(data, {
 		causer,
 		uid,
@@ -290,19 +333,159 @@ var ContextStorageQueryHandler = class ContextStorageQueryHandler {
 	}
 };
 
+//#endregion
+//#region src/injectionSymbols.ts
+const contextStorageCollectionInjectKey = collection;
+const contextStorageCollectionItemInjectKey = collectionItem;
+const contextStorageHandlersInjectKey = handlers;
+const contextStorageQueryHandlerInjectKey = contextStorageQueryHandler;
+
+//#endregion
+//#region src/components/ContextStorageActivator.vue?vue&type=script&lang.ts
+var ContextStorageActivator_vue_vue_type_script_lang_default = defineComponent({ setup(_, { slots }) {
+	const collection$1 = inject(contextStorageCollectionInjectKey);
+	const item = inject(contextStorageCollectionItemInjectKey);
+	const onActivate = () => {
+		collection$1.setActive(item);
+	};
+	return () => h("div", { onMousedown: onActivate }, slots.default?.());
+} });
+
+//#endregion
+//#region src/components/ContextStorageActivator.vue
+var ContextStorageActivator_default = ContextStorageActivator_vue_vue_type_script_lang_default;
+
+//#endregion
+//#region src/constants.ts
+const defaultHandlers = [ContextStorageQueryHandler];
+
+//#endregion
+//#region src/components/ContextStorageCollection.vue?vue&type=script&lang.ts
+var ContextStorageCollection_vue_vue_type_script_lang_default = defineComponent({
+	props: { handlers: {
+		type: Object,
+		default: () => defaultHandlers
+	} },
+	setup({ handlers: handlers$1 }, { slots }) {
+		const lastActive = computed({
+			get: () => localStorage.getItem("context-storage-last-active") || "main",
+			set: (value) => localStorage.setItem("context-storage-last-active", value)
+		});
+		const router = useRouter();
+		const initialNavigatorState = /* @__PURE__ */ new Map();
+		const initialNavigatorStateResolvers = /* @__PURE__ */ new Map();
+		handlers$1.forEach((handler) => {
+			if (!handler.getInitialStateResolver) return;
+			initialNavigatorStateResolvers.set(handler, handler.getInitialStateResolver());
+		});
+		router.isReady().then(() => {
+			initialNavigatorStateResolvers.forEach((resolver, handler) => {
+				initialNavigatorState.set(handler, resolver());
+			});
+			activateLastActiveItem();
+		});
+		const collection$1 = new ContextStorageCollection(handlers$1);
+		collection$1.onActiveChange((item) => {
+			lastActive.value = item.key;
+		});
+		provide(contextStorageCollectionInjectKey, collection$1);
+		const activateInitialItem = (item) => {
+			item.handlers.forEach((handler) => {
+				const state = initialNavigatorState.get(handler.constructor);
+				if (!state) return;
+				handler.setInitialState?.(state);
+			});
+			collection$1.setActive(item);
+		};
+		const activateLastActiveItem = () => {
+			const lastActiveItem = collection$1.findItemByKey(lastActive.value);
+			if (lastActiveItem) {
+				activateInitialItem(lastActiveItem);
+				return;
+			}
+			const firstItem = collection$1.first();
+			if (!firstItem) throw new Error("[ContextStorage] Cannot find first item in collection");
+			activateInitialItem(firstItem);
+		};
+		return () => {
+			return slots.default?.();
+		};
+	}
+});
+
+//#endregion
+//#region src/components/ContextStorageCollection.vue
+var ContextStorageCollection_default = ContextStorageCollection_vue_vue_type_script_lang_default;
+
+//#endregion
+//#region src/components/ContextStorageProvider.vue?vue&type=script&lang.ts
+var ContextStorageProvider_vue_vue_type_script_lang_default = defineComponent({
+	props: { itemKey: {
+		type: String,
+		required: true
+	} },
+	setup(props, { slots }) {
+		const collection$1 = inject(contextStorageCollectionInjectKey);
+		if (!collection$1) throw new Error("[ContextStorage] Context storage collection not found");
+		const item = collection$1.add({ key: props.itemKey });
+		provide(contextStorageCollectionItemInjectKey, item);
+		provide(contextStorageHandlersInjectKey, item.handlers);
+		item.handlers.forEach((handler) => {
+			provide(handler.getInjectionKey(), handler);
+		});
+		onUnmounted(() => {
+			collection$1.remove(item);
+		});
+		return () => slots.default?.();
+	}
+});
+
+//#endregion
+//#region src/components/ContextStorageProvider.vue
+var ContextStorageProvider_default = ContextStorageProvider_vue_vue_type_script_lang_default;
+
+//#endregion
+//#region src/components/ContextStorage.vue?vue&type=script&setup=true&lang.ts
+var ContextStorage_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "ContextStorage",
+	props: { handlers: {
+		type: Array,
+		required: true,
+		default: () => defaultHandlers
+	} },
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(ContextStorageCollection_default, { handlers: __props.handlers }, {
+				default: withCtx(() => [createVNode(ContextStorageProvider_default, { "item-key": "main" }, {
+					default: withCtx(() => [createVNode(ContextStorageActivator_default, null, {
+						default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+						_: 3
+					})]),
+					_: 3
+				})]),
+				_: 3
+			}, 8, ["handlers"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/ContextStorage.vue
+var ContextStorage_default = ContextStorage_vue_vue_type_script_setup_true_lang_default;
+
 //#endregion
 //#region src/handlers/query/transform-helpers.ts
 function asNumber(value, options) {
 	const { nullable = false, missable = false, fallbackValue = missable ? void 0 : nullable ? null : 0 } = options || {};
 	if (value === null && nullable) return null;
-	if (value === void 0 && missable) return void 0;
+	if (value === void 0 && missable) return;
 	value = Number(value);
 	return isNaN(value) ? fallbackValue : value;
 }
 function asString(value, options) {
 	const { nullable = false, missable = false, fallbackValue = missable ? void 0 : nullable ? null : "", allowedValues } = options || {};
 	if (value === null && nullable) return null;
-	if (value === void 0 && missable) return void 0;
+	if (value === void 0 && missable) return;
 	const stringValue = value ?? fallbackValue;
 	if (allowedValues && typeof stringValue === "string" && !allowedValues.includes(stringValue)) return fallbackValue;
 	return stringValue;
@@ -324,7 +507,7 @@ function asNumberArray(value, options) {
 function asArray(value, options) {
 	const { nullable = false, missable = false, transform: transform$1 } = options || {};
 	if (value === null && nullable) return null;
-	if (value === void 0 && missable) return void 0;
+	if (value === void 0 && missable) return;
 	if (value === void 0) return nullable ? null : [];
 	let arrayValue;
 	if (Array.isArray(value)) arrayValue = value;
@@ -335,7 +518,7 @@ function asArray(value, options) {
 function asBoolean(value, options) {
 	const { nullable = false, missable = false, fallbackValue = missable ? void 0 : nullable ? null : false } = options || {};
 	if (value === null && nullable) return null;
-	if (value === void 0 && missable) return void 0;
+	if (value === void 0 && missable) return;
 	if (value === void 0 || value === null) return fallbackValue;
 	if (typeof value === "string") {
 		const lowerValue = value.toLowerCase();
@@ -353,16 +536,4 @@ const transform = {
 };
 
 //#endregion
-//#region src/injectionSymbols.ts
-const contextStorageCollectionInjectKey = collection;
-const contextStorageCollectionItemInjectKey = collectionItem;
-const contextStorageHandlersInjectKey = handlers;
-const contextStorageQueryHandlerInjectKey = contextStorageQueryHandler;
-
-//#endregion
-//#region src/constants.ts
-const defaultHandlers = [ContextStorageQueryHandler];
-
-//#endregion
-export { ContextStorageQueryHandler, asArray, asBoolean, asNumber, asNumberArray, asString, collection, collectionItem, contextStorageCollectionInjectKey, contextStorageCollectionItemInjectKey, contextStorageHandlersInjectKey, contextStorageQueryHandler, contextStorageQueryHandlerInjectKey, defaultHandlers, deserializeParams, handlers, serializeParams, transform, useContextStorageQueryHandler };
-//# sourceMappingURL=index.js.map
+export { ContextStorage_default as ContextStorage, ContextStorageActivator_default as ContextStorageActivator, ContextStorageCollection_default as ContextStorageCollection, ContextStorageProvider_default as ContextStorageProvider, ContextStorageQueryHandler, asArray, asBoolean, asNumber, asNumberArray, asString, collection, collectionItem, contextStorageCollectionInjectKey, contextStorageCollectionItemInjectKey, contextStorageHandlersInjectKey, contextStorageQueryHandler, contextStorageQueryHandlerInjectKey, defaultHandlers, deserializeParams, handlers, serializeParams, transform, useContextStorageQueryHandler };