vue-context-storage 0.1.9 → 0.1.11

package/dist/index.d.ts

@@ -1,14 +1,414 @@
-import type { ContextStorageHandlerConstructor } from './handlers';
-export { default as ContextStorageActivator } from './components/ContextStorageActivator.vue';
-export { default as ContextStorageCollection } from './components/ContextStorageCollection.vue';
-export { default as ContextStorageProvider } from './components/ContextStorageProvider.vue';
-export { default as ContextStorage } from './components/ContextStorage.vue';
-export type { ContextStorageHandler, ContextStorageHandlerConstructor, RegisterBaseOptions, } from './handlers';
-export { ContextStorageQueryHandler, useContextStorageQueryHandler } from './handlers/query';
-export { deserializeParams, serializeParams } from './handlers/query/helpers.ts';
-export type { SerializeOptions } from './handlers/query/helpers.ts';
-export { asArray, asBoolean, asNumber, asNumberArray, asString, transform, } from './handlers/query/transform-helpers.ts';
-export { contextStorageCollectionInjectKey, contextStorageCollectionItemInjectKey, contextStorageHandlersInjectKey, contextStorageQueryHandlerInjectKey, } from './injectionSymbols';
-export { collection, collectionItem, contextStorageQueryHandler, handlers } from './symbols';
-export declare const defaultHandlers: ContextStorageHandlerConstructor[];
-export type { QueryValue, IContextStorageQueryHandler } from './handlers/query/types';
+import * as vue0 from "vue";
+import { InjectionKey, MaybeRefOrGetter, Plugin, 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/plugin.d.ts
+declare const VueContextStoragePlugin: Plugin;
+//#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, VueContextStoragePlugin, 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";
 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,
@@ -298,8 +341,8 @@ const contextStorageHandlersInjectKey = handlers;
 const contextStorageQueryHandlerInjectKey = contextStorageQueryHandler;
 
 //#endregion
-//#region src/components/ContextStorageActivator.vue
-const _sfc_main$3 = defineComponent({ setup(_, { slots }) {
+//#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 = () => {
@@ -307,59 +350,21 @@ const _sfc_main$3 = defineComponent({ setup(_, { slots }) {
 	};
 	return () => h("div", { onMousedown: onActivate }, slots.default?.());
 } });
-var ContextStorageActivator_default = _sfc_main$3;
 
 //#endregion
-//#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 handlers$1 = this.handlerConstructors.map((constructor) => new constructor());
-		const item = {
-			handlers: handlers$1,
-			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));
-	}
-};
+//#region src/components/ContextStorageActivator.vue
+var ContextStorageActivator_default = ContextStorageActivator_vue_vue_type_script_lang_default;
 
 //#endregion
-//#region src/components/ContextStorageCollection.vue
-const _sfc_main$2 = defineComponent({
+//#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
+		default: () => defaultHandlers
 	} },
 	setup({ handlers: handlers$1 }, { slots }) {
 		const lastActive = computed({
@@ -407,11 +412,14 @@ const _sfc_main$2 = defineComponent({
 		};
 	}
 });
-var ContextStorageCollection_default = _sfc_main$2;
 
 //#endregion
-//#region src/components/ContextStorageProvider.vue
-const _sfc_main$1 = defineComponent({
+//#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
@@ -431,13 +439,20 @@ const _sfc_main$1 = defineComponent({
 		return () => slots.default?.();
 	}
 });
-var ContextStorageProvider_default = _sfc_main$1;
 
 //#endregion
-//#region src/components/ContextStorage.vue
-const _sfc_main = /* @__PURE__ */ defineComponent({
+//#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: { default: () => defaultHandlers } },
+	props: { handlers: {
+		type: Array,
+		required: true,
+		default: () => defaultHandlers
+	} },
 	setup(__props) {
 		return (_ctx, _cache) => {
 			return openBlock(), createBlock(ContextStorageCollection_default, { handlers: __props.handlers }, {
@@ -453,21 +468,33 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 		};
 	}
 });
-var ContextStorage_default = _sfc_main;
+
+//#endregion
+//#region src/components/ContextStorage.vue
+var ContextStorage_default = ContextStorage_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/plugin.ts
+const VueContextStoragePlugin = { install(app) {
+	app.component("ContextStorageActivator", ContextStorageActivator_default);
+	app.component("ContextStorageCollection", ContextStorageCollection_default);
+	app.component("ContextStorageProvider", ContextStorageProvider_default);
+	app.component("ContextStorage", ContextStorage_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;
@@ -489,7 +516,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;
@@ -500,7 +527,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();
@@ -518,9 +545,4 @@ const transform = {
 };
 
 //#endregion
-//#region src/index.ts
-const defaultHandlers = [ContextStorageQueryHandler];
-
-//#endregion
-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 };
-//# sourceMappingURL=index.js.map
+export { ContextStorage_default as ContextStorage, ContextStorageActivator_default as ContextStorageActivator, ContextStorageCollection_default as ContextStorageCollection, ContextStorageProvider_default as ContextStorageProvider, ContextStorageQueryHandler, VueContextStoragePlugin, asArray, asBoolean, asNumber, asNumberArray, asString, collection, collectionItem, contextStorageCollectionInjectKey, contextStorageCollectionItemInjectKey, contextStorageHandlersInjectKey, contextStorageQueryHandler, contextStorageQueryHandlerInjectKey, defaultHandlers, deserializeParams, handlers, serializeParams, transform, useContextStorageQueryHandler };