vue3-router-tab 1.0.9 → 1.1.1

package/index.d.ts

@@ -1,134 +0,0 @@
-import type { App, Plugin } from 'vue'
-import type { RouteLocationRaw } from 'vue-router'
-import type {
-  TabRecord,
-  TabInput,
-  RouterTabsOptions,
-  CloseTabOptions,
-  RouterTabsContext,
-  RouterTabsMenuConfig,
-  RouterTabsMenuItem,
-  RouterTabsMenuPreset,
-  RouterTabsSnapshot,
-  RouterTabsSnapshotTab
-} from './lib/core/types'
-
-export type {
-  TabRecord,
-  TabInput,
-  RouterTabsOptions,
-  CloseTabOptions,
-  RouterTabsContext,
-  RouterTabsMenuConfig,
-  RouterTabsMenuItem,
-  RouterTabsMenuPreset,
-  RouterTabsSnapshot,
-  RouterTabsSnapshotTab
-}
-
-export declare const routerTabsKey: import('vue').InjectionKey<RouterTabsContext>
-
-export declare function useRouterTabs(options?: { optional?: boolean }): RouterTabsContext | null
-
-export interface RouterTabsPiniaOptions {
-  storeId?: string
-  storageKey?: string
-  storage?: Storage | null
-  fallbackRoute?: import('vue-router').RouteLocationRaw
-}
-
-export declare function useRouterTabsPiniaPersistence(options?: RouterTabsPiniaOptions & { store?: import('pinia').StoreDefinition<any, any, any, any> }): import('pinia').Store<any, any, any, any>
-
-export declare const RouterTabsPinia: import('vue').DefineComponent<RouterTabsPiniaOptions, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<RouterTabsPiniaOptions>, {}>
-
-export declare const RouterTab: import('vue').DefineComponent<{
-  tabs: {
-    type: import('vue').PropType<TabInput[]>
-    default: () => TabInput[]
-  }
-  keepAlive: {
-    type: BooleanConstructor
-    default: boolean
-  }
-  maxAlive: {
-    type: NumberConstructor
-    default: number
-  }
-  keepLastTab: {
-    type: BooleanConstructor
-    default: boolean
-  }
-  append: {
-    type: import('vue').PropType<'last' | 'next'>
-    default: 'last' | 'next'
-  }
-  defaultPage: {
-    type: import('vue').PropType<RouteLocationRaw>
-    default: RouteLocationRaw
-  }
-  tabTransition: {
-    type: import('vue').PropType<import('./lib/core/types').TransitionLike>
-    default: string | import('./lib/core/types').TransitionLike
-  }
-  pageTransition: {
-    type: import('vue').PropType<import('./lib/core/types').TransitionLike>
-    default: () => import('./lib/core/types').TransitionLike
-  }
-  contextmenu: {
-    type: import('vue').PropType<boolean | RouterTabsMenuConfig[]>
-    default: true
-  }
-  storage: {
-    type: BooleanConstructor | StringConstructor
-    default: boolean
-  }
-}, any, any, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<{
-  tabs?: TabInput[] | undefined
-  keepAlive?: boolean | undefined
-  maxAlive?: number | undefined
-  keepLastTab?: boolean | undefined
-  append?: 'last' | 'next' | undefined
-  defaultPage?: RouteLocationRaw | undefined
-  tabTransition?: import('./lib/core/types').TransitionLike | undefined
-  pageTransition?: import('./lib/core/types').TransitionLike | undefined
-  contextmenu?: boolean | RouterTabsMenuConfig[] | undefined
-  storage?: boolean | string | undefined
-}> & {
-  tabs?: TabInput[] | undefined
-  keepAlive?: boolean | undefined
-  maxAlive?: number | undefined
-  keepLastTab?: boolean | undefined
-  append?: 'last' | 'next' | undefined
-  defaultPage?: RouteLocationRaw | undefined
-  tabTransition?: import('./lib/core/types').TransitionLike | undefined
-  pageTransition?: import('./lib/core/types').TransitionLike | undefined
-  contextmenu?: boolean | RouterTabsMenuConfig[] | undefined
-  storage?: boolean | string | undefined
-}, {
-  tabs: TabInput[]
-  keepAlive: boolean
-  maxAlive: number
-  keepLastTab: boolean
-  append: 'last' | 'next'
-  defaultPage: RouteLocationRaw
-  tabTransition: import('./lib/core/types').TransitionLike
-  pageTransition: import('./lib/core/types').TransitionLike
-  contextmenu: true
-  storage: boolean
-}>
-
-export interface RouterTabPlugin extends Plugin {}
-
-declare const plugin: RouterTabPlugin
-
-export default plugin
-
-declare module '@vue/runtime-core' {
-  interface ComponentCustomProperties {
-    $tabs: RouterTabsContext | null
-  }
-}
-declare module './constants' {
-  const value: any;
-  export = value;
-}

package/lib/components/RouterTabsPinia.vue

@@ -1,13 +0,0 @@
-<template>
-  <span class="router-tabs" aria-hidden="true" />
-</template>
-
-<script setup lang="ts">
-import { useRouterTabsPiniaPersistence } from '../pinia'
-defineOptions({ name: 'RouterTabs' })
-import type { RouterTabsPiniaOptions } from '../pinia'
-
-const props = defineProps<RouterTabsPiniaOptions>()
-
-useRouterTabsPiniaPersistence(props as RouterTabsPiniaOptions)
-</script>

package/lib/pinia.ts

@@ -1,149 +0,0 @@
-import { defineStore, type StoreDefinition } from 'pinia'
-import { onMounted, ref, watch } from 'vue'
-import type { RouteLocationRaw } from 'vue-router'
-import { useRouterTabs } from './useRouterTabs'
-import type { RouterTabsSnapshot } from './core/types'
-
-export interface RouterTabsPiniaOptions {
-  /** Pinia store id. Defaults to 'routerTabs'. */
-  storeId?: string
-  /** Storage key used when persisting snapshots. Defaults to 'router-tabs:persistent'. */
-  storageKey?: string
-  /** Custom storage implementation (e.g. localStorage, sessionStorage). Defaults to window.localStorage. */
-  storage?: Storage | null
-  /** Fallback route to open when no snapshot exists. Defaults to RouterTab's default route. */
-  fallbackRoute?: RouteLocationRaw
-  /** Provide a custom store definition if you want to control persistence yourself. */
-  store?: StoreDefinition<'routerTabs', { snapshot: RouterTabsSnapshot | null }, {}, { load(): void; setSnapshot(snapshot: RouterTabsSnapshot | null): void; clear(): void }>
-}
-
-const defaultStorageKey = 'router-tabs:persistent'
-
-function resolveStorage(storage?: Storage | null): Storage | null {
-  if (typeof window === 'undefined') return null
-  if (storage === undefined) return window.localStorage ?? null
-  return storage
-}
-
-function createDefaultStore(options: RouterTabsPiniaOptions) {
-  const storage = resolveStorage(options.storage)
-  const key = options.storageKey ?? defaultStorageKey
-
-  return defineStore(options.storeId ?? 'routerTabs', {
-    state: () => ({
-      snapshot: null as RouterTabsSnapshot | null
-    }),
-    actions: {
-      load() {
-        if (!storage || this.snapshot) return
-        try {
-          const raw = storage.getItem(key)
-          if (raw) {
-            this.snapshot = JSON.parse(raw)
-          }
-        } catch (error) {
-          if (import.meta.env?.DEV) {
-            console.warn('[RouterTabs] Failed to load snapshot from storage', error)
-          }
-        }
-      },
-      setSnapshot(snapshot: RouterTabsSnapshot | null) {
-        this.snapshot = snapshot
-        if (!storage) return
-
-        try {
-          if (snapshot && snapshot.tabs.length) {
-            storage.setItem(key, JSON.stringify(snapshot))
-          } else {
-            storage.removeItem(key)
-          }
-        } catch (error) {
-          if (import.meta.env?.DEV) {
-            console.warn('[RouterTabs] Failed to persist snapshot to storage', error)
-          }
-        }
-      },
-      clear() {
-        this.setSnapshot(null)
-      }
-    }
-  })
-}
-
-/**
- * Synchronise RouterTab state with a Pinia store so tab snapshots persist across reloads.
- *
- * ```ts
- * const store = useRouterTabsPiniaPersistence()
- * ```
- */
-export function useRouterTabsPiniaPersistence(options: RouterTabsPiniaOptions = {}) {
-  const Store = options.store ?? createDefaultStore(options)
-  const store = Store()
-  const hydrating = ref(false)
-  let initialized = false
-
-  const attemptSetup = (controller: NonNullable<ReturnType<typeof useRouterTabs>>) => {
-    if (!controller || initialized) return
-    initialized = true
-
-    onMounted(async () => {
-      store.load()
-      const snapshot = store.snapshot
-
-      if (snapshot && snapshot.tabs?.length) {
-        try {
-          hydrating.value = true
-          await controller.hydrate(snapshot)
-        } finally {
-          hydrating.value = false
-        }
-      } else {
-        try {
-          hydrating.value = true
-          const fallback = options.fallbackRoute ?? controller.options.defaultRoute
-          await controller.reset(fallback)
-        } finally {
-          hydrating.value = false
-        }
-      }
-
-      store.setSnapshot(controller.snapshot())
-    })
-
-    watch(
-      () => ({
-        tabs: controller.tabs.map(tab => ({
-          to: tab.to,
-          title: tab.title,
-          tips: tab.tips,
-          icon: tab.icon,
-          tabClass: tab.tabClass,
-          closable: tab.closable
-        })),
-        active: controller.activeId.value
-      }),
-      () => {
-        if (hydrating.value) return
-        store.setSnapshot(controller.snapshot())
-      },
-      { deep: true }
-    )
-  }
-
-  const controller = useRouterTabs({ optional: true })
-  if (controller) {
-    attemptSetup(controller)
-  } else {
-    onMounted(() => {
-      const lateController = useRouterTabs({ optional: true })
-      if (lateController) {
-        attemptSetup(lateController)
-      } else if (import.meta.env?.DEV) {
-        console.warn('[RouterTabs] Pinia helper must be used inside <router-tab>.')
-      }
-    })
-  }
-
-  return store
-}