vue-context-storage 0.1.8 → 0.1.10

package/src/handlers/query/types.ts

@@ -1,125 +0,0 @@
-import { LocationQueryValue } from 'vue-router'
-import { MaybeRefOrGetter, UnwrapNestedRefs, WatchHandle } from 'vue'
-import { ContextStorageHandler, RegisterBaseOptions } from '../../handlers'
-
-export type QueryValue = LocationQueryValue | LocationQueryValue[]
-
-// A recursive type that transforms all properties to CustomType
-export type DeepTransformValuesToLocationQueryValue<T> = {
-  [K in keyof T]?: T[K] extends object // Check if the property is an object
-    ? // Exclude Array from being treated as an object for recursion
-      T[K] extends Array<any>
-      ? QueryValue // Arrays will just become the CustomType (or you could handle them differently)
-      : DeepTransformValuesToLocationQueryValue<T[K]> // Recursively apply the type to nested objects
-    : QueryValue // Non-object (leaf) properties get the CustomType
-}
-
-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
-}
-
-export 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
-}
-
-export 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>
-}
-
-export interface RegisterQueryHandlerOptions<T>
-  extends RegisterBaseOptions, RegisterQueryHandlerBaseOptions<T> {}
-
-export interface IContextStorageQueryHandler extends ContextStorageHandler {
-  register: <T extends Record<string, unknown>>(
-    data: MaybeRefOrGetter<T>,
-    options: RegisterQueryHandlerOptions<T>,
-  ) => () => void
-}
-
-export interface ContextStorageQueryRegisteredItem<T extends Record<string, unknown>> {
-  data: MaybeRefOrGetter<T>
-  initialData: T
-  options: RegisterQueryHandlerOptions<T>
-  watchHandle: WatchHandle
-}

package/src/handlers.ts

@@ -1,18 +0,0 @@
-import type { InjectionKey, MaybeRefOrGetter } from 'vue'
-
-export interface ContextStorageHandlerConstructor {
-  new (): ContextStorageHandler
-  getInitialStateResolver?: () => () => Record<string, unknown>
-}
-
-export interface RegisterBaseOptions {
-  causer: string
-  uid: number
-}
-
-export interface ContextStorageHandler {
-  register: (data: MaybeRefOrGetter, options: RegisterBaseOptions) => () => void
-  setInitialState?: (state: Record<string, unknown>) => void
-  setEnabled?: (enabled: boolean, initial: boolean) => void
-  getInjectionKey(): InjectionKey<ContextStorageHandler>
-}

package/src/index.ts

@@ -1,40 +0,0 @@
-// Core exports
-export type {
-  ContextStorageHandler,
-  ContextStorageHandlerConstructor,
-  RegisterBaseOptions,
-} from './handlers'
-
-export { ContextStorageQueryHandler, useContextStorageQueryHandler } from './handlers/query'
-
-// Query helpers
-export { deserializeParams, serializeParams } from './handlers/query/helpers'
-export type { SerializeOptions } from './handlers/query/helpers'
-
-// Query transform helpers
-export {
-  asArray,
-  asBoolean,
-  asNumber,
-  asNumberArray,
-  asString,
-  transform,
-} from './handlers/query/transform-helpers'
-
-// Injection symbols
-export {
-  contextStorageCollectionInjectKey,
-  contextStorageCollectionItemInjectKey,
-  contextStorageHandlersInjectKey,
-  contextStorageQueryHandlerInjectKey,
-} from './injectionSymbols'
-
-// Symbols
-export { collection, collectionItem, contextStorageQueryHandler, handlers } from './symbols'
-
-// Re-export defaultHandlers from constants to ensure single instance
-export { defaultHandlers } from './constants'
-export type { QueryValue, IContextStorageQueryHandler } from './handlers/query/types'
-
-// Export only type for ContextStorageCollectionItem to avoid naming conflict with component
-export type { ContextStorageCollectionItem } from './collection'

package/src/injectionSymbols.ts

@@ -1,15 +0,0 @@
-import { ContextStorageCollection, ContextStorageCollectionItem } from './collection'
-import { ContextStorageQueryHandler } from './handlers/query'
-import { collection, collectionItem, contextStorageQueryHandler, handlers } from './symbols'
-import { InjectionKey } from 'vue'
-
-export const contextStorageCollectionInjectKey: InjectionKey<ContextStorageCollection> = collection
-export const contextStorageCollectionItemInjectKey: InjectionKey<ContextStorageCollectionItem> =
-  collectionItem
-export const contextStorageHandlersInjectKey: InjectionKey<
-  ContextStorageCollectionItem['handlers']
-> = handlers
-
-export const contextStorageQueryHandlerInjectKey: InjectionKey<
-  InstanceType<typeof ContextStorageQueryHandler>
-> = contextStorageQueryHandler

package/src/main.ts

@@ -1,12 +0,0 @@
-// Main entry point that includes everything (for ESM usage)
-// This ensures all imports come from the same module instance
-export * from './index'
-
-// Components
-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'
-
-// Plugin
-export { VueContextStoragePlugin, VueContextStoragePlugin as default } from './plugin'

package/src/plugin.ts

@@ -1,16 +0,0 @@
-import type { App, Plugin } from 'vue'
-import ContextStorageActivator from './components/ContextStorageActivator.vue'
-import ContextStorageCollection from './components/ContextStorageCollection.vue'
-import ContextStorageProvider from './components/ContextStorageProvider.vue'
-import ContextStorage from './components/ContextStorage.vue'
-
-export const VueContextStoragePlugin: Plugin = {
-  install(app: App) {
-    app.component('ContextStorageActivator', ContextStorageActivator)
-    app.component('ContextStorageCollection', ContextStorageCollection)
-    app.component('ContextStorageProvider', ContextStorageProvider)
-    app.component('ContextStorage', ContextStorage)
-  },
-}
-
-export default VueContextStoragePlugin

package/src/shims-vue.d.ts

@@ -1,5 +0,0 @@
-declare module '*.vue' {
-  import type { DefineComponent } from 'vue'
-  const component: DefineComponent<{}, {}, any>
-  export default component
-}

package/src/symbols.ts

@@ -1,4 +0,0 @@
-export const collection: unique symbol = Symbol('context-storage-collection')
-export const collectionItem: unique symbol = Symbol('context-storage-collection-item')
-export const handlers: unique symbol = Symbol('context-storage-handlers')
-export const contextStorageQueryHandler: unique symbol = Symbol('context-storage-query-handler')