@tanstack/query-core 4.0.0

package/src/removable.ts

@@ -0,0 +1,37 @@
+import { isServer, isValidTimeout } from './utils'
+
+export abstract class Removable {
+  cacheTime!: number
+  private gcTimeout?: ReturnType<typeof setTimeout>
+
+  destroy(): void {
+    this.clearGcTimeout()
+  }
+
+  protected scheduleGc(): void {
+    this.clearGcTimeout()
+
+    if (isValidTimeout(this.cacheTime)) {
+      this.gcTimeout = setTimeout(() => {
+        this.optionalRemove()
+      }, this.cacheTime)
+    }
+  }
+
+  protected updateCacheTime(newCacheTime: number | undefined): void {
+    // Default to 5 minutes (Infinity for server-side) if no cache time is set
+    this.cacheTime = Math.max(
+      this.cacheTime || 0,
+      newCacheTime ?? (isServer ? Infinity : 5 * 60 * 1000),
+    )
+  }
+
+  protected clearGcTimeout() {
+    if (this.gcTimeout) {
+      clearTimeout(this.gcTimeout)
+      this.gcTimeout = undefined
+    }
+  }
+
+  protected abstract optionalRemove(): void
+}

package/src/retryer.ts

@@ -0,0 +1,215 @@
+import { focusManager } from './focusManager'
+import { onlineManager } from './onlineManager'
+import { sleep } from './utils'
+import { CancelOptions, NetworkMode } from './types'
+
+// TYPES
+
+interface RetryerConfig<TData = unknown, TError = unknown> {
+  fn: () => TData | Promise<TData>
+  abort?: () => void
+  onError?: (error: TError) => void
+  onSuccess?: (data: TData) => void
+  onFail?: (failureCount: number, error: TError) => void
+  onPause?: () => void
+  onContinue?: () => void
+  retry?: RetryValue<TError>
+  retryDelay?: RetryDelayValue<TError>
+  networkMode: NetworkMode | undefined
+}
+
+export interface Retryer<TData = unknown> {
+  promise: Promise<TData>
+  cancel: (cancelOptions?: CancelOptions) => void
+  continue: () => void
+  cancelRetry: () => void
+  continueRetry: () => void
+}
+
+export type RetryValue<TError> = boolean | number | ShouldRetryFunction<TError>
+
+type ShouldRetryFunction<TError> = (
+  failureCount: number,
+  error: TError,
+) => boolean
+
+export type RetryDelayValue<TError> = number | RetryDelayFunction<TError>
+
+type RetryDelayFunction<TError = unknown> = (
+  failureCount: number,
+  error: TError,
+) => number
+
+function defaultRetryDelay(failureCount: number) {
+  return Math.min(1000 * 2 ** failureCount, 30000)
+}
+
+export function canFetch(networkMode: NetworkMode | undefined): boolean {
+  return (networkMode ?? 'online') === 'online'
+    ? onlineManager.isOnline()
+    : true
+}
+
+export class CancelledError {
+  revert?: boolean
+  silent?: boolean
+  constructor(options?: CancelOptions) {
+    this.revert = options?.revert
+    this.silent = options?.silent
+  }
+}
+
+export function isCancelledError(value: any): value is CancelledError {
+  return value instanceof CancelledError
+}
+
+export function createRetryer<TData = unknown, TError = unknown>(
+  config: RetryerConfig<TData, TError>,
+): Retryer<TData> {
+  let isRetryCancelled = false
+  let failureCount = 0
+  let isResolved = false
+  let continueFn: ((value?: unknown) => void) | undefined
+  let promiseResolve: (data: TData) => void
+  let promiseReject: (error: TError) => void
+
+  const promise = new Promise<TData>((outerResolve, outerReject) => {
+    promiseResolve = outerResolve
+    promiseReject = outerReject
+  })
+
+  const cancel = (cancelOptions?: CancelOptions): void => {
+    if (!isResolved) {
+      reject(new CancelledError(cancelOptions))
+
+      config.abort?.()
+    }
+  }
+  const cancelRetry = () => {
+    isRetryCancelled = true
+  }
+
+  const continueRetry = () => {
+    isRetryCancelled = false
+  }
+
+  const shouldPause = () =>
+    !focusManager.isFocused() ||
+    (config.networkMode !== 'always' && !onlineManager.isOnline())
+
+  const resolve = (value: any) => {
+    if (!isResolved) {
+      isResolved = true
+      config.onSuccess?.(value)
+      continueFn?.()
+      promiseResolve(value)
+    }
+  }
+
+  const reject = (value: any) => {
+    if (!isResolved) {
+      isResolved = true
+      config.onError?.(value)
+      continueFn?.()
+      promiseReject(value)
+    }
+  }
+
+  const pause = () => {
+    return new Promise((continueResolve) => {
+      continueFn = (value) => {
+        if (isResolved || !shouldPause()) {
+          return continueResolve(value)
+        }
+      }
+      config.onPause?.()
+    }).then(() => {
+      continueFn = undefined
+      if (!isResolved) {
+        config.onContinue?.()
+      }
+    })
+  }
+
+  // Create loop function
+  const run = () => {
+    // Do nothing if already resolved
+    if (isResolved) {
+      return
+    }
+
+    let promiseOrValue: any
+
+    // Execute query
+    try {
+      promiseOrValue = config.fn()
+    } catch (error) {
+      promiseOrValue = Promise.reject(error)
+    }
+
+    Promise.resolve(promiseOrValue)
+      .then(resolve)
+      .catch((error) => {
+        // Stop if the fetch is already resolved
+        if (isResolved) {
+          return
+        }
+
+        // Do we need to retry the request?
+        const retry = config.retry ?? 3
+        const retryDelay = config.retryDelay ?? defaultRetryDelay
+        const delay =
+          typeof retryDelay === 'function'
+            ? retryDelay(failureCount, error)
+            : retryDelay
+        const shouldRetry =
+          retry === true ||
+          (typeof retry === 'number' && failureCount < retry) ||
+          (typeof retry === 'function' && retry(failureCount, error))
+
+        if (isRetryCancelled || !shouldRetry) {
+          // We are done if the query does not need to be retried
+          reject(error)
+          return
+        }
+
+        failureCount++
+
+        // Notify on fail
+        config.onFail?.(failureCount, error)
+
+        // Delay
+        sleep(delay)
+          // Pause if the document is not visible or when the device is offline
+          .then(() => {
+            if (shouldPause()) {
+              return pause()
+            }
+          })
+          .then(() => {
+            if (isRetryCancelled) {
+              reject(error)
+            } else {
+              run()
+            }
+          })
+      })
+  }
+
+  // Start loop
+  if (canFetch(config.networkMode)) {
+    run()
+  } else {
+    pause().then(run)
+  }
+
+  return {
+    promise,
+    cancel,
+    continue: () => {
+      continueFn?.()
+    },
+    cancelRetry,
+    continueRetry,
+  }
+}

package/src/subscribable.ts

@@ -0,0 +1,33 @@
+type Listener = () => void
+
+export class Subscribable<TListener extends Function = Listener> {
+  protected listeners: TListener[]
+
+  constructor() {
+    this.listeners = []
+    this.subscribe = this.subscribe.bind(this)
+  }
+
+  subscribe(listener: TListener): () => void {
+    this.listeners.push(listener as TListener)
+
+    this.onSubscribe()
+
+    return () => {
+      this.listeners = this.listeners.filter((x) => x !== listener)
+      this.onUnsubscribe()
+    }
+  }
+
+  hasListeners(): boolean {
+    return this.listeners.length > 0
+  }
+
+  protected onSubscribe(): void {
+    // Do nothing
+  }
+
+  protected onUnsubscribe(): void {
+    // Do nothing
+  }
+}

package/src/tests/focusManager.test.tsx

@@ -0,0 +1,155 @@
+import { sleep } from '../utils'
+import { FocusManager } from '../focusManager'
+import { setIsServer } from '../../../../tests/utils'
+
+describe('focusManager', () => {
+  let focusManager: FocusManager
+  beforeEach(() => {
+    jest.resetModules()
+    focusManager = new FocusManager()
+  })
+
+  it('should call previous remove handler when replacing an event listener', () => {
+    const remove1Spy = jest.fn()
+    const remove2Spy = jest.fn()
+
+    focusManager.setEventListener(() => remove1Spy)
+    focusManager.setEventListener(() => remove2Spy)
+
+    expect(remove1Spy).toHaveBeenCalledTimes(1)
+    expect(remove2Spy).not.toHaveBeenCalled()
+  })
+
+  it('should use focused boolean arg', async () => {
+    let count = 0
+
+    const setup = (setFocused: (focused?: boolean) => void) => {
+      setTimeout(() => {
+        count++
+        setFocused(true)
+      }, 20)
+      return () => void 0
+    }
+
+    focusManager.setEventListener(setup)
+
+    await sleep(30)
+    expect(count).toEqual(1)
+    expect(focusManager.isFocused()).toBeTruthy()
+  })
+
+  it('should not notify listeners on focus if already focused', async () => {
+    const subscriptionSpy = jest.fn()
+    const unsubscribe = focusManager.subscribe(subscriptionSpy)
+
+    focusManager.setFocused(true)
+    expect(subscriptionSpy).toHaveBeenCalledTimes(1)
+    subscriptionSpy.mockReset()
+
+    focusManager.setFocused(false)
+    expect(subscriptionSpy).toHaveBeenCalledTimes(0)
+
+    unsubscribe()
+  })
+
+  it('should return true for isFocused if document is undefined', async () => {
+    const { document } = globalThis
+
+    // @ts-expect-error
+    delete globalThis.document
+
+    focusManager.setFocused()
+    expect(focusManager.isFocused()).toBeTruthy()
+    globalThis.document = document
+  })
+
+  test('cleanup should still be undefined if window is not defined', async () => {
+    const restoreIsServer = setIsServer(true)
+
+    const unsubscribe = focusManager.subscribe(() => undefined)
+    expect(focusManager['cleanup']).toBeUndefined()
+
+    unsubscribe()
+    restoreIsServer()
+  })
+
+  test('cleanup should still be undefined if window.addEventListener is not defined', async () => {
+    const { addEventListener } = globalThis.window
+
+    // @ts-expect-error
+    globalThis.window.addEventListener = undefined
+
+    const unsubscribe = focusManager.subscribe(() => undefined)
+    expect(focusManager['cleanup']).toBeUndefined()
+
+    unsubscribe()
+    globalThis.window.addEventListener = addEventListener
+  })
+
+  it('should replace default window listener when a new event listener is set', async () => {
+    const addEventListenerSpy = jest.spyOn(
+      globalThis.window,
+      'addEventListener',
+    )
+
+    const removeEventListenerSpy = jest.spyOn(
+      globalThis.window,
+      'removeEventListener',
+    )
+
+    // Should set the default event listener with window event listeners
+    const unsubscribe = focusManager.subscribe(() => undefined)
+    expect(addEventListenerSpy).toHaveBeenCalledTimes(2)
+
+    // Should replace the window default event listener by a new one
+    // and it should call window.removeEventListener twice
+    focusManager.setEventListener(() => {
+      return () => void 0
+    })
+
+    expect(removeEventListenerSpy).toHaveBeenCalledTimes(2)
+
+    unsubscribe()
+    addEventListenerSpy.mockRestore()
+    removeEventListenerSpy.mockRestore()
+  })
+
+  test('should call removeEventListener when last listener unsubscribes', () => {
+    const addEventListenerSpy = jest.spyOn(
+      globalThis.window,
+      'addEventListener',
+    )
+
+    const removeEventListenerSpy = jest.spyOn(
+      globalThis.window,
+      'removeEventListener',
+    )
+
+    const unsubscribe1 = focusManager.subscribe(() => undefined)
+    const unsubscribe2 = focusManager.subscribe(() => undefined)
+    expect(addEventListenerSpy).toHaveBeenCalledTimes(2) // visibilitychange + focus
+
+    unsubscribe1()
+    expect(removeEventListenerSpy).toHaveBeenCalledTimes(0)
+    unsubscribe2()
+    expect(removeEventListenerSpy).toHaveBeenCalledTimes(2) // visibilitychange + focus
+  })
+
+  test('should keep setup function even if last listener unsubscribes', () => {
+    const setupSpy = jest.fn().mockImplementation(() => () => undefined)
+
+    focusManager.setEventListener(setupSpy)
+
+    const unsubscribe1 = focusManager.subscribe(() => undefined)
+
+    expect(setupSpy).toHaveBeenCalledTimes(1)
+
+    unsubscribe1()
+
+    const unsubscribe2 = focusManager.subscribe(() => undefined)
+
+    expect(setupSpy).toHaveBeenCalledTimes(2)
+
+    unsubscribe2()
+  })
+})