init

packages/svelte/use-swr.ts

@@ -0,0 +1,195 @@
+import { onDestroy } from 'svelte'
+import { writable, derived } from 'svelte/store'
+import { createSWR } from '../../core'
+import type { SWRConfig, SWRStores, SWRStore, Key, Fetcher, SWRFetcher } from './types'
+
+// Global SWR instance
+const globalSWR = createSWR()
+
+/**
+ * Enhanced useSWR store for Svelte
+ */
+export function useSWR<Data = unknown, Error = unknown>(
+  key: Key | null,
+  fetcher?: SWRFetcher<Data> | null,
+  config?: Partial<SWRConfig<Data, Error>>
+): SWRStores<Data, Error> {
+  // Get config from context (using a simple object for now)
+  const contextConfig = {} as Record<string, unknown>
+  const mergedConfig = {
+    ...contextConfig,
+    ...config
+  }
+
+  // Update config if provided
+  if (mergedConfig) {
+    globalSWR.updateConfig(mergedConfig as any)
+  }
+
+  // Initial state logic
+  let initialData: Data | undefined = undefined
+  let initialError: Error | undefined = undefined
+  let initialIsLoading = false
+  let initialIsValidating = false
+
+  if (key) {
+    const entry = globalSWR.get(key)
+    if (entry) {
+      initialData = entry.data as Data
+      initialError = entry.error as Error
+      initialIsLoading = entry.isLoading
+      initialIsValidating = entry.isValidating
+    }
+  }
+
+  // Create base stores
+  const dataStore = writable<Data | undefined>(initialData)
+  const errorStore = writable<Error | undefined>(initialError)
+  const isLoadingStore = writable<boolean>(initialIsLoading)
+  const isValidatingStore = writable<boolean>(initialIsValidating)
+
+  // Subscribe to SWR changes
+  let unsubscribe: (() => void) | undefined
+
+  const normalizedFetcher = fetcher ? (
+    fetcher.length === 2 ? fetcher as Fetcher<Data> : (k: Key, options: unknown) => {
+      if (Array.isArray(k)) {
+        return (fetcher as (...args: unknown[]) => Promise<Data>)(...k)
+      }
+      return (fetcher as (arg: unknown) => Promise<Data>)(k)
+    }
+  ) : null
+
+  if (key) {
+    unsubscribe = globalSWR.subscribe(key, (newData, newError, newIsValidating, newIsLoading) => {
+      dataStore.set(newData as Data)
+      errorStore.set(newError as Error)
+      isValidatingStore.set(newIsValidating ?? false)
+      isLoadingStore.set(newIsLoading ?? false)
+    }, normalizedFetcher as Fetcher<Data>)
+  }
+
+  // Cleanup on destroy if inside a component
+  try {
+    onDestroy(() => {
+      if (unsubscribe) unsubscribe()
+    })
+  } catch (e) {
+    // Ignore error if called outside component initialization
+    // (e.g. in tests without a component context)
+  }
+
+  // Create mutate function
+  const mutate = (mutateData?: Data | Promise<Data> | ((currentData?: Data) => Data | Promise<Data>), options?: unknown) => {
+    if (!key) return Promise.resolve(undefined)
+    return globalSWR.mutate(key, mutateData, options as any)
+  }
+
+  return {
+    data: { subscribe: dataStore.subscribe },
+    error: { subscribe: errorStore.subscribe },
+    isLoading: { subscribe: isLoadingStore.subscribe },
+    isValidating: { subscribe: isValidatingStore.subscribe },
+    loading: { subscribe: isLoadingStore.subscribe },
+    validating: { subscribe: isValidatingStore.subscribe },
+    mutate: mutate as any
+  }
+}
+
+/**
+ * Enhanced useSWR store with all state combined
+ */
+export function useSWRStore<Data = unknown, Error = unknown>(
+  key: Key | null,
+  fetcher?: SWRFetcher<Data> | null,
+  config?: Partial<SWRConfig<Data, Error>>
+): SWRStore<Data, Error> {
+  const stores = useSWR<Data, Error>(key, fetcher, config)
+  
+  let initialData: Data | undefined;
+  let initialError: Error | undefined;
+  let initialIsLoading = false;
+  let initialIsValidating = false;
+  
+  stores.data.subscribe(v => initialData = v)();
+  stores.error.subscribe(v => initialError = v)();
+  stores.isLoading.subscribe(v => initialIsLoading = v)();
+  stores.isValidating.subscribe(v => initialIsValidating = v)();
+
+  const combinedStore = writable<{
+    data?: Data
+    error?: Error
+    isLoading: boolean
+    isValidating: boolean
+    loading: boolean
+    validating: boolean
+  }>({
+    data: initialData,
+    error: initialError,
+    isLoading: initialIsLoading,
+    isValidating: initialIsValidating,
+    loading: initialIsLoading,
+    validating: initialIsValidating
+  })
+
+  // Update combined store when individual stores change
+  const unsubscribeData = stores.data.subscribe((data: any) => {
+    combinedStore.update((state: any) => ({ ...state, data }))
+  })
+  
+  const unsubscribeError = stores.error.subscribe((error: any) => {
+    combinedStore.update((state: any) => ({ ...state, error }))
+  })
+  
+  const unsubscribeLoading = stores.isLoading.subscribe((isLoading: any) => {
+    combinedStore.update((state: any) => ({ ...state, isLoading, loading: isLoading }))
+  })
+  
+  const unsubscribeValidating = stores.isValidating.subscribe((isValidating) => {
+    combinedStore.update((state) => ({ ...state, isValidating, validating: isValidating }))
+  })
+
+  // Cleanup on destroy
+  try {
+    onDestroy(() => {
+      unsubscribeData()
+      unsubscribeError()
+      unsubscribeLoading()
+      unsubscribeValidating()
+    })
+  } catch (e) {
+    // Ignore
+  }
+
+  return {
+    ...combinedStore,
+    mutate: stores.mutate
+  }
+}
+
+/**
+ * Hook for manual mutation
+ */
+export function useSWRMutate<Data = unknown, Error = unknown>() {
+  return (key: Key, data?: Data | Promise<Data> | ((currentData?: Data) => Data | Promise<Data>), options?: unknown) => {
+    return globalSWR.mutate(key, data, options as any)
+  }
+}
+
+/**
+ * Hook for accessing global SWR instance
+ */
+export function useSWRInstance() {
+  return globalSWR
+}
+
+/**
+ * Hook for prefetching data
+ */
+export function useSWRPrefetch<Data = any, Error = any>() {
+  return (key: Key, fetcher: Fetcher<Data>) => {
+    return globalSWR.revalidate(key, { dedupe: true })
+  }
+}
+
+export default useSWR