Revert "refactor(core): unify focusManager and onlineManager"

This reverts commit f1cb1a6.

src/core/focusManager.ts

@@ -1,31 +1,76 @@
-import { createEventManager } from './eventManager'
-
-export const createFocusManager = () => {
-  const { setEventListener, subscribe, ...manager } = createEventManager([
-    'visibilitychange',
-    'focus',
-  ])
-
-  return {
-    subscribe,
-    setEventListener,
-    setFocused: manager.setValue,
-    isFocused: (): boolean => {
-      const value = manager.getValue()
-      if (typeof value === 'boolean') {
-        return value
-      }
+import { Subscribable } from './subscribable'
+import { isServer } from './utils'
+
+class FocusManager extends Subscribable {
+  private focused?: boolean
+  private removeEventListener?: () => void
+
+  protected onSubscribe(): void {
+    if (!this.removeEventListener) {
+      this.setDefaultEventListener()
+    }
+  }
 
-      // document global can be unavailable in react native
-      if (typeof document === 'undefined') {
-        return true
+  setEventListener(
+    setup: (setFocused: (focused?: boolean) => void) => () => void
+  ): void {
+    if (this.removeEventListener) {
+      this.removeEventListener()
+    }
+    this.removeEventListener = setup(focused => {
+      if (typeof focused === 'boolean') {
+        this.setFocused(focused)
+      } else {
+        this.onFocus()
       }
+    })
+  }
+
+  setFocused(focused?: boolean): void {
+    this.focused = focused
+
+    if (focused) {
+      this.onFocus()
+    }
+  }
+
+  onFocus(): void {
+    this.listeners.forEach(listener => {
+      listener()
+    })
+  }
+
+  isFocused(): boolean {
+    if (typeof this.focused === 'boolean') {
+      return this.focused
+    }
+
+    // document global can be unavailable in react native
+    if (typeof document === 'undefined') {
+      return true
+    }
+
+    return [undefined, 'visible', 'prerender'].includes(
+      document.visibilityState
+    )
+  }
+
+  private setDefaultEventListener() {
+    if (!isServer && window?.addEventListener) {
+      this.setEventListener(onFocus => {
+        const listener = () => onFocus()
+        // Listen to visibillitychange and focus
+        window.addEventListener('visibilitychange', listener, false)
+        window.addEventListener('focus', listener, false)
 
-      return [undefined, 'visible', 'prerender'].includes(
-        document.visibilityState
-      )
-    },
+        return () => {
+          // Be sure to unsubscribe if a new handler is set
+          window.removeEventListener('visibilitychange', listener)
+          window.removeEventListener('focus', listener)
+        }
+      })
+    }
   }
 }
 
-export const focusManager = createFocusManager()
+export const focusManager = new FocusManager()

src/core/onlineManager.ts

@@ -1,31 +1,76 @@
-import { createEventManager } from './eventManager'
-
-export const createOnlineManager = () => {
-  const { setEventListener, subscribe, ...manager } = createEventManager([
-    'online',
-    'offline',
-  ])
-
-  return {
-    subscribe,
-    setEventListener,
-    setOnline: manager.setValue,
-    isOnline: (): boolean => {
-      const value = manager.getValue()
-      if (typeof value === 'boolean') {
-        return value
-      }
+import { Subscribable } from './subscribable'
+import { isServer } from './utils'
+
+class OnlineManager extends Subscribable {
+  private online?: boolean
+  private removeEventListener?: () => void
+
+  protected onSubscribe(): void {
+    if (!this.removeEventListener) {
+      this.setDefaultEventListener()
+    }
+  }
 
-      if (
-        typeof navigator === 'undefined' ||
-        typeof navigator.onLine === 'undefined'
-      ) {
-        return true
+  setEventListener(
+    setup: (setOnline: (online?: boolean) => void) => () => void
+  ): void {
+    if (this.removeEventListener) {
+      this.removeEventListener()
+    }
+    this.removeEventListener = setup((online?: boolean) => {
+      if (typeof online === 'boolean') {
+        this.setOnline(online)
+      } else {
+        this.onOnline()
       }
+    })
+  }
+
+  setOnline(online?: boolean): void {
+    this.online = online
+
+    if (online) {
+      this.onOnline()
+    }
+  }
+
+  onOnline(): void {
+    this.listeners.forEach(listener => {
+      listener()
+    })
+  }
+
+  isOnline(): boolean {
+    if (typeof this.online === 'boolean') {
+      return this.online
+    }
+
+    if (
+      typeof navigator === 'undefined' ||
+      typeof navigator.onLine === 'undefined'
+    ) {
+      return true
+    }
+
+    return navigator.onLine
+  }
+
+  private setDefaultEventListener() {
+    if (!isServer && window?.addEventListener) {
+      this.setEventListener(onOnline => {
+        const listener = () => onOnline()
+        // Listen to online
+        window.addEventListener('online', listener, false)
+        window.addEventListener('offline', listener, false)
 
-      return navigator.onLine
-    },
+        return () => {
+          // Be sure to unsubscribe if a new handler is set
+          window.removeEventListener('online', listener)
+          window.removeEventListener('offline', listener)
+        }
+      })
+    }
   }
 }
 
-export const onlineManager = createOnlineManager()
+export const onlineManager = new OnlineManager()

src/core/tests/focusManager.test.tsx

@@ -1,10 +1,10 @@
 import { sleep } from '../utils'
-import { createFocusManager } from '../focusManager'
+import { focusManager } from '../focusManager'
 
 describe('focusManager', () => {
-  let focusManager: ReturnType<typeof createFocusManager>
-  beforeEach(() => {
-    focusManager = createFocusManager()
+  afterEach(() => {
+    // Reset removeEventListener private property to avoid side effects between tests
+    focusManager['removeEventListener'] = undefined
   })
 
   it('should call previous remove handler when replacing an event listener', () => {
@@ -69,7 +69,7 @@ describe('focusManager', () => {
 
     const setEventListenerSpy = jest.spyOn(focusManager, 'setEventListener')
 
-    const unsubscribe = focusManager.subscribe(() => undefined)
+    const unsubscribe = focusManager.subscribe()
     expect(setEventListenerSpy).toHaveBeenCalledTimes(0)
 
     unsubscribe()
@@ -88,7 +88,7 @@ describe('focusManager', () => {
     )
 
     // Should set the default event listener with window event listeners
-    const unsubscribe = focusManager.subscribe(() => undefined)
+    const unsubscribe = focusManager.subscribe()
     expect(addEventListenerSpy).toHaveBeenCalledTimes(2)
 
     // Should replace the window default event listener by a new one

src/core/tests/onlineManager.test.tsx

@@ -1,10 +1,10 @@
-import { createOnlineManager } from '../onlineManager'
+import { onlineManager } from '../onlineManager'
 import { sleep } from '../utils'
 
 describe('onlineManager', () => {
-  let onlineManager: ReturnType<typeof createOnlineManager>
-  beforeEach(() => {
-    onlineManager = createOnlineManager()
+  afterEach(() => {
+    // Reset removeEventListener private property to avoid side effects between tests
+    onlineManager['removeEventListener'] = undefined
   })
 
   test('isOnline should return true if navigator is undefined', () => {
@@ -64,7 +64,7 @@ describe('onlineManager', () => {
 
     const setEventListenerSpy = jest.spyOn(onlineManager, 'setEventListener')
 
-    const unsubscribe = onlineManager.subscribe(() => undefined)
+    const unsubscribe = onlineManager.subscribe()
     expect(setEventListenerSpy).toHaveBeenCalledTimes(0)
 
     unsubscribe()
@@ -83,7 +83,7 @@ describe('onlineManager', () => {
     )
 
     // Should set the default event listener with window event listeners
-    const unsubscribe = onlineManager.subscribe(() => undefined)
+    const unsubscribe = onlineManager.subscribe()
     expect(addEventListenerSpy).toHaveBeenCalledTimes(2)
 
     // Should replace the window default event listener by a new one