react-rx 3.0.0-0 → 3.0.0-1

package/dist/es2015/useAsObservable.js

@@ -1,43 +0,0 @@
-import { BehaviorSubject } from 'rxjs';
-import { useCallback, useEffect, useRef } from 'react';
-import { distinctUntilChanged } from 'rxjs/operators';
-export function useAsObservable(value, operator) {
-    const setup = useCallback(() => {
-        const subject = new BehaviorSubject(value);
-        const observable = subject.asObservable().pipe(distinctUntilChanged());
-        return [operator ? observable.pipe(operator) : observable, subject];
-    }, []);
-    const ref = useRef();
-    if (!ref.current) {
-        ref.current = setup();
-    }
-    const [observable] = ref.current;
-    useEffect(() => {
-        if (!ref.current) {
-            return;
-        }
-        const [, subject] = ref.current;
-        subject.next(value);
-    }, [value, ref]);
-    const shouldRestoreSubscriptionRef = useRef(false);
-    useEffect(() => {
-        if (shouldRestoreSubscriptionRef.current) {
-            if (!ref.current) {
-                ref.current = setup();
-            }
-            shouldRestoreSubscriptionRef.current = false;
-        }
-        return () => {
-            if (!ref.current) {
-                return;
-            }
-            // React StrictMode will call effects as `setup + teardown + setup` thus we can't trust this callback as "react is about to unmount"
-            // Tracking this ref lets us set the subscription back up on the next `setup` call if needed, and if it really did unmounted then all is well
-            shouldRestoreSubscriptionRef.current = true;
-            const [, subject] = ref.current;
-            subject.complete();
-            ref.current = undefined;
-        };
-    }, []);
-    return observable;
-}

package/dist/es2015/useWithObservable.d.ts

@@ -1,9 +0,0 @@
-import { Observable } from 'rxjs';
-/**
- * React hook to convert any props or state value into an observable
- * Returns an observable representing updates to any React value (props, state or any other calculated value)
- * Note: the returned observable is the same instance throughout the component lifecycle
- * @param value
- */
-export declare function useWithObservable<T>(value: T): T | undefined;
-export declare function useWithObservable<T, K>(value: T, operator: (input: Observable<T>) => Observable<K>): K | undefined;

package/dist/es2015/useWithObservable.js

@@ -1,7 +0,0 @@
-import { useObservable } from './useObservable';
-import { useAsObservable } from './useAsObservable';
-export function useWithObservable(value, operator) {
-    return operator
-        ? useObservable(useAsObservable(value, operator))
-        : useObservable(useAsObservable(value));
-}

package/dist/es2015/utils.d.ts

@@ -1,7 +0,0 @@
-import { Observable, OperatorFunction } from 'rxjs';
-import { Dispatch, SetStateAction, Context } from 'react';
-export declare function observeState<T>(initial: T | (() => T)): [Observable<T>, Dispatch<SetStateAction<T>>];
-export declare function observeCallback<T>(): [Observable<T>, (arg: T) => void];
-export declare function observeCallback<T, K>(operator: OperatorFunction<T, K>): [Observable<K>, (arg: T) => void];
-export declare function observeContext<T>(context: Context<T>): Observable<T>;
-export declare function observeElement<T>(): [Observable<T | null>, (el: T | null) => void];

package/dist/es2015/utils.js

@@ -1,31 +0,0 @@
-import { useAsObservable } from './useAsObservable';
-import { observableCallback } from 'observable-callback';
-import { startWith } from 'rxjs/operators';
-import { useContext, useRef, useState } from 'react';
-const createState = (initialState) => observableCallback(startWith(initialState));
-export function observeState(initial) {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const [value, update] = useState(initial);
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return [useAsObservable(value), update];
-}
-export function observeCallback(operator) {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const ref = useRef();
-    if (!ref.current) {
-        ref.current = operator ? observableCallback(operator) : observableCallback();
-    }
-    return ref.current;
-}
-export function observeContext(context) {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return useAsObservable(useContext(context));
-}
-export function observeElement() {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const ref = useRef();
-    if (!ref.current) {
-        ref.current = createState(null);
-    }
-    return ref.current;
-}

package/dist/esm/WithObservable.d.ts

@@ -1,12 +0,0 @@
-import { Observable } from 'rxjs';
-import { ComponentType, ReactNode } from 'react';
-interface Props<T> {
-    observable: Observable<T>;
-    children: (value: T) => ReactNode;
-}
-type ObservableComponent<T> = ComponentType<Props<T>>;
-/**
- * @deprecated Use the useObservable hook instead
- */
-export declare const WithObservable: ObservableComponent<unknown>;
-export {};

package/dist/esm/WithObservable.js

@@ -1,13 +0,0 @@
-import { distinctUntilChanged, map, switchMap } from 'rxjs/operators';
-import { reactiveComponent } from './reactiveComponent';
-function createWithObservable() {
-    return reactiveComponent(function (props$) {
-        return props$.pipe(distinctUntilChanged(function (props, prevProps) { return props.observable === prevProps.observable; }), switchMap(function (props) {
-            return props.observable.pipe(map(function (observableValue) { return props.children(observableValue); }));
-        }));
-    });
-}
-/**
- * @deprecated Use the useObservable hook instead
- */
-export var WithObservable = createWithObservable();

package/dist/esm/__tests__/useAsObservable.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/__tests__/useAsObservable.test.js

@@ -1,73 +0,0 @@
-import { useAsObservable } from '../useAsObservable';
-import React from 'react';
-import { renderHook } from '@testing-library/react';
-import { test, expect } from 'vitest';
-test('the returned observable should receive a new value when component is rendered with a new value', function () {
-    var receivedValues = [];
-    var _a = renderHook(function (props) {
-        var observable = useAsObservable(props.value);
-        React.useEffect(function () {
-            var subscription = observable.subscribe(function (v) {
-                receivedValues.push(v);
-            });
-            return function () {
-                subscription.unsubscribe();
-            };
-        }, []);
-    }, { initialProps: { value: 'initial' } }), unmount = _a.unmount, rerender = _a.rerender;
-    rerender({ value: 'rerender' });
-    rerender({ value: 'rerender again' });
-    expect(receivedValues).toEqual(['initial', 'rerender', 'rerender again']);
-    unmount();
-});
-test('the returned observable should *not* receive a new value when component is rendered with an unchanged value', function () {
-    var receivedValues = [];
-    var _a = renderHook(function (props) {
-        var observable = useAsObservable(props.value);
-        React.useEffect(function () {
-            var subscription = observable.subscribe(function (v) {
-                receivedValues.push(v);
-            });
-            return function () {
-                subscription.unsubscribe();
-            };
-        }, []);
-    }, { initialProps: { value: 'some value' } }), unmount = _a.unmount, rerender = _a.rerender;
-    rerender({ value: 'some value' });
-    rerender({ value: 'some value' });
-    expect(receivedValues).toEqual(['some value']);
-    unmount();
-});
-test('the returned observable should have the same identity across multiple re-renders/hook calls', function () {
-    var returnValues = [];
-    var _a = renderHook(function () {
-        returnValues.push(useAsObservable('render'));
-    }), unmount = _a.unmount, rerender = _a.rerender;
-    rerender();
-    rerender();
-    var initial = returnValues[0], firstRerender = returnValues[1], secondRerender = returnValues[2];
-    expect(initial).toBe(firstRerender);
-    expect(firstRerender).toBe(secondRerender);
-    unmount();
-});
-test('the returned observable should complete on unmount', function () {
-    var didComplete = false;
-    var _a = renderHook(function () {
-        var observable = useAsObservable('render');
-        React.useEffect(function () {
-            var subscription = observable.subscribe({
-                complete: function () {
-                    didComplete = true;
-                },
-            });
-            return function () {
-                subscription.unsubscribe();
-            };
-        }, []);
-    }), unmount = _a.unmount, rerender = _a.rerender;
-    expect(didComplete).toBe(false);
-    rerender();
-    expect(didComplete).toBe(false);
-    unmount();
-    expect(didComplete).toBe(true);
-});

package/dist/esm/displayName.d.ts

@@ -1 +0,0 @@
-export declare const wrapDisplayName: (BaseComponent: Function, wrapperName: string) => string;

package/dist/esm/displayName.js

@@ -1,10 +0,0 @@
-var getDisplayName = function (Component) {
-    if (typeof Component === 'string') {
-        return Component;
-    }
-    return (Component && (Component.displayName || Component.name)) || 'Unknown';
-};
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/ban-types
-export var wrapDisplayName = function (BaseComponent, wrapperName) {
-    return "".concat(wrapperName, "(").concat(getDisplayName(BaseComponent), ")");
-};

package/dist/esm/reactiveComponent.d.ts

@@ -1,8 +0,0 @@
-import { Observable } from 'rxjs';
-import { FunctionComponent, ReactNode, Ref } from 'react';
-type Component<Props> = (input$: Observable<Props>) => Observable<ReactNode>;
-export declare function reactiveComponent<Props>(observable: Observable<Props>): FunctionComponent<Props>;
-export declare function reactiveComponent<Props>(component: Component<Props>): FunctionComponent<Props>;
-type ForwardRefComponent<RefType, Props> = (input$: Observable<Props>, ref: Ref<RefType>) => Observable<ReactNode>;
-export declare function forwardRef<RefType, Props = {}>(component: ForwardRefComponent<RefType, Props>): import("react").ForwardRefExoticComponent<import("react").PropsWithoutRef<Props> & import("react").RefAttributes<RefType>>;
-export {};

package/dist/esm/reactiveComponent.js

@@ -1,30 +0,0 @@
-import { wrapDisplayName } from './displayName';
-import { useAsObservable } from './useAsObservable';
-import { useObservable } from './useObservable';
-import { createElement, Fragment, useRef, forwardRef as reactForwardRef, } from 'react';
-function fromComponent(component) {
-    var wrappedComponent = function (props) {
-        return createElement(Fragment, null, useObservable(useRef(component(useAsObservable(props))).current));
-    };
-    wrappedComponent.displayName = wrapDisplayName(component, 'reactiveComponent');
-    return wrappedComponent;
-}
-// eslint-disable-next-line @typescript-eslint/ban-types
-function fromObservable(input$) {
-    return function ReactiveComponent() {
-        return createElement(Fragment, null, useObservable(input$));
-    };
-}
-export function reactiveComponent(observableOrComponent) {
-    return typeof observableOrComponent === 'function'
-        ? fromComponent(observableOrComponent)
-        : fromObservable(observableOrComponent);
-}
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/ban-types
-export function forwardRef(component) {
-    var wrappedComponent = reactForwardRef(function (props, ref) {
-        return createElement(Fragment, null, useObservable(useRef(component(useAsObservable(props), ref)).current));
-    });
-    wrappedComponent.displayName = wrapDisplayName(component, 'reactiveComponent');
-    return wrappedComponent;
-}

package/dist/esm/useAsObservable.d.ts

@@ -1,10 +0,0 @@
-import { Observable } from 'rxjs';
-/**
- * React hook to convert any props or state value into an observable
- * Returns an observable representing updates to any React value (props, state or any other calculated value)
- * Note: the returned observable is the same instance throughout the component lifecycle
- * @param value
- * @deprecated use an `of` operator and `useMemoObservable` instead for a faster, more robust and  siimpler solution
- */
-export declare function useAsObservable<T>(value: T): Observable<T>;
-export declare function useAsObservable<T, K>(value: T, operator: (input: Observable<T>) => Observable<K>): Observable<K>;

package/dist/esm/useAsObservable.js

@@ -1,43 +0,0 @@
-import { BehaviorSubject } from 'rxjs';
-import { useCallback, useEffect, useRef } from 'react';
-import { distinctUntilChanged } from 'rxjs/operators';
-export function useAsObservable(value, operator) {
-    var setup = useCallback(function () {
-        var subject = new BehaviorSubject(value);
-        var observable = subject.asObservable().pipe(distinctUntilChanged());
-        return [operator ? observable.pipe(operator) : observable, subject];
-    }, []);
-    var ref = useRef();
-    if (!ref.current) {
-        ref.current = setup();
-    }
-    var observable = ref.current[0];
-    useEffect(function () {
-        if (!ref.current) {
-            return;
-        }
-        var _a = ref.current, subject = _a[1];
-        subject.next(value);
-    }, [value, ref]);
-    var shouldRestoreSubscriptionRef = useRef(false);
-    useEffect(function () {
-        if (shouldRestoreSubscriptionRef.current) {
-            if (!ref.current) {
-                ref.current = setup();
-            }
-            shouldRestoreSubscriptionRef.current = false;
-        }
-        return function () {
-            if (!ref.current) {
-                return;
-            }
-            // React StrictMode will call effects as `setup + teardown + setup` thus we can't trust this callback as "react is about to unmount"
-            // Tracking this ref lets us set the subscription back up on the next `setup` call if needed, and if it really did unmounted then all is well
-            shouldRestoreSubscriptionRef.current = true;
-            var _a = ref.current, subject = _a[1];
-            subject.complete();
-            ref.current = undefined;
-        };
-    }, []);
-    return observable;
-}

package/dist/esm/useWithObservable.d.ts

@@ -1,9 +0,0 @@
-import { Observable } from 'rxjs';
-/**
- * React hook to convert any props or state value into an observable
- * Returns an observable representing updates to any React value (props, state or any other calculated value)
- * Note: the returned observable is the same instance throughout the component lifecycle
- * @param value
- */
-export declare function useWithObservable<T>(value: T): T | undefined;
-export declare function useWithObservable<T, K>(value: T, operator: (input: Observable<T>) => Observable<K>): K | undefined;

package/dist/esm/useWithObservable.js

@@ -1,7 +0,0 @@
-import { useObservable } from './useObservable';
-import { useAsObservable } from './useAsObservable';
-export function useWithObservable(value, operator) {
-    return operator
-        ? useObservable(useAsObservable(value, operator))
-        : useObservable(useAsObservable(value));
-}

package/dist/esm/utils.d.ts

@@ -1,7 +0,0 @@
-import { Observable, OperatorFunction } from 'rxjs';
-import { Dispatch, SetStateAction, Context } from 'react';
-export declare function observeState<T>(initial: T | (() => T)): [Observable<T>, Dispatch<SetStateAction<T>>];
-export declare function observeCallback<T>(): [Observable<T>, (arg: T) => void];
-export declare function observeCallback<T, K>(operator: OperatorFunction<T, K>): [Observable<K>, (arg: T) => void];
-export declare function observeContext<T>(context: Context<T>): Observable<T>;
-export declare function observeElement<T>(): [Observable<T | null>, (el: T | null) => void];

package/dist/esm/utils.js

@@ -1,31 +0,0 @@
-import { useAsObservable } from './useAsObservable';
-import { observableCallback } from 'observable-callback';
-import { startWith } from 'rxjs/operators';
-import { useContext, useRef, useState } from 'react';
-var createState = function (initialState) { return observableCallback(startWith(initialState)); };
-export function observeState(initial) {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    var _a = useState(initial), value = _a[0], update = _a[1];
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return [useAsObservable(value), update];
-}
-export function observeCallback(operator) {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    var ref = useRef();
-    if (!ref.current) {
-        ref.current = operator ? observableCallback(operator) : observableCallback();
-    }
-    return ref.current;
-}
-export function observeContext(context) {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return useAsObservable(useContext(context));
-}
-export function observeElement() {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    var ref = useRef();
-    if (!ref.current) {
-        ref.current = createState(null);
-    }
-    return ref.current;
-}

package/src/WithObservable.tsx

@@ -1,29 +0,0 @@
-import * as React from 'react'
-import {Observable} from 'rxjs'
-import {distinctUntilChanged, map, switchMap} from 'rxjs/operators'
-import {reactiveComponent} from './reactiveComponent'
-import {ComponentType, ReactNode} from 'react'
-
-interface Props<T> {
-  observable: Observable<T>
-  children: (value: T) => ReactNode
-}
-
-type ObservableComponent<T> = ComponentType<Props<T>>
-
-function createWithObservable<T>(): ObservableComponent<T> {
-  return reactiveComponent((props$: Observable<Props<T>>) =>
-    props$.pipe(
-      distinctUntilChanged((props, prevProps) => props.observable === prevProps.observable),
-      switchMap(
-        (props): Observable<ReactNode> =>
-          props.observable.pipe(map((observableValue: T) => props.children(observableValue))),
-      ),
-    ),
-  )
-}
-
-/**
- * @deprecated Use the useObservable hook instead
- */
-export const WithObservable = createWithObservable()

package/src/__tests__/useAsObservable.test.tsx

@@ -1,95 +0,0 @@
-import {useAsObservable} from '../useAsObservable'
-import React from 'react'
-import {renderHook} from '@testing-library/react'
-import {Observable} from 'rxjs'
-import {test, expect} from 'vitest'
-
-test('the returned observable should receive a new value when component is rendered with a new value', () => {
-  const receivedValues: string[] = []
-  const {unmount, rerender} = renderHook(
-    (props: {value: string}) => {
-      const observable = useAsObservable(props.value)
-
-      React.useEffect(() => {
-        const subscription = observable.subscribe(v => {
-          receivedValues.push(v)
-        })
-        return () => {
-          subscription.unsubscribe()
-        }
-      }, [])
-    },
-    {initialProps: {value: 'initial'}},
-  )
-
-  rerender({value: 'rerender'})
-  rerender({value: 'rerender again'})
-
-  expect(receivedValues).toEqual(['initial', 'rerender', 'rerender again'])
-
-  unmount()
-})
-
-test('the returned observable should *not* receive a new value when component is rendered with an unchanged value', () => {
-  const receivedValues: string[] = []
-  const {unmount, rerender} = renderHook(
-    (props: {value: string}) => {
-      const observable = useAsObservable(props.value)
-
-      React.useEffect(() => {
-        const subscription = observable.subscribe(v => {
-          receivedValues.push(v)
-        })
-        return () => {
-          subscription.unsubscribe()
-        }
-      }, [])
-    },
-    {initialProps: {value: 'some value'}},
-  )
-
-  rerender({value: 'some value'})
-  rerender({value: 'some value'})
-
-  expect(receivedValues).toEqual(['some value'])
-
-  unmount()
-})
-
-test('the returned observable should have the same identity across multiple re-renders/hook calls', () => {
-  const returnValues: Observable<unknown>[] = []
-  const {unmount, rerender} = renderHook(() => {
-    returnValues.push(useAsObservable('render'))
-  })
-
-  rerender()
-  rerender()
-
-  const [initial, firstRerender, secondRerender] = returnValues
-  expect(initial).toBe(firstRerender)
-  expect(firstRerender).toBe(secondRerender)
-  unmount()
-})
-
-test('the returned observable should complete on unmount', () => {
-  let didComplete = false
-  const {unmount, rerender} = renderHook(() => {
-    const observable = useAsObservable('render')
-
-    React.useEffect(() => {
-      const subscription = observable.subscribe({
-        complete: () => {
-          didComplete = true
-        },
-      })
-      return () => {
-        subscription.unsubscribe()
-      }
-    }, [])
-  })
-  expect(didComplete).toBe(false)
-  rerender()
-  expect(didComplete).toBe(false)
-  unmount()
-  expect(didComplete).toBe(true)
-})

package/src/displayName.ts

@@ -1,11 +0,0 @@
-const getDisplayName = (Component: any) => {
-  if (typeof Component === 'string') {
-    return Component
-  }
-
-  return (Component && (Component.displayName || Component.name)) || 'Unknown'
-}
-
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/ban-types
-export const wrapDisplayName = (BaseComponent: Function, wrapperName: string) =>
-  `${wrapperName}(${getDisplayName(BaseComponent)})`

package/src/reactiveComponent.ts

@@ -1,63 +0,0 @@
-/* eslint-disable react-hooks/rules-of-hooks */
-import {Observable} from 'rxjs'
-import {wrapDisplayName} from './displayName'
-import {useAsObservable} from './useAsObservable'
-import {useObservable} from './useObservable'
-import {
-  createElement,
-  Fragment,
-  FunctionComponent,
-  ReactNode,
-  Ref,
-  useRef,
-  forwardRef as reactForwardRef,
-} from 'react'
-
-type Component<Props> = (input$: Observable<Props>) => Observable<ReactNode>
-
-function fromComponent<Props>(component: Component<Props>): FunctionComponent<Props> {
-  const wrappedComponent = (props: Props) => {
-    return createElement(
-      Fragment,
-      null,
-      useObservable<ReactNode>(useRef(component(useAsObservable(props))).current),
-    )
-  }
-  wrappedComponent.displayName = wrapDisplayName(component, 'reactiveComponent')
-  return wrappedComponent
-}
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-function fromObservable<Props>(input$: Observable<ReactNode>): FunctionComponent<{}> {
-  return function ReactiveComponent() {
-    return createElement(Fragment, null, useObservable<ReactNode>(input$))
-  }
-}
-
-export function reactiveComponent<Props>(observable: Observable<Props>): FunctionComponent<Props>
-export function reactiveComponent<Props>(component: Component<Props>): FunctionComponent<Props>
-export function reactiveComponent<Props>(
-  observableOrComponent: Observable<ReactNode> | Component<Props>,
-) {
-  return typeof observableOrComponent === 'function'
-    ? fromComponent(observableOrComponent)
-    : fromObservable(observableOrComponent)
-}
-
-type ForwardRefComponent<RefType, Props> = (
-  input$: Observable<Props>,
-  ref: Ref<RefType>,
-) => Observable<ReactNode>
-
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/ban-types
-export function forwardRef<RefType, Props = {}>(component: ForwardRefComponent<RefType, Props>) {
-  const wrappedComponent = reactForwardRef((props: Props, ref: Ref<RefType>) => {
-    return createElement(
-      Fragment,
-      null,
-      useObservable<ReactNode>(useRef(component(useAsObservable(props), ref)).current),
-    )
-  })
-  wrappedComponent.displayName = wrapDisplayName(component, 'reactiveComponent')
-  return wrappedComponent
-}

package/src/useAsObservable.ts

@@ -1,66 +0,0 @@
-import {BehaviorSubject, Observable} from 'rxjs'
-import {useCallback, useEffect, useRef} from 'react'
-import {distinctUntilChanged} from 'rxjs/operators'
-
-/**
- * React hook to convert any props or state value into an observable
- * Returns an observable representing updates to any React value (props, state or any other calculated value)
- * Note: the returned observable is the same instance throughout the component lifecycle
- * @param value
- * @deprecated use an `of` operator and `useMemoObservable` instead for a faster, more robust and  siimpler solution
- */
-export function useAsObservable<T>(value: T): Observable<T>
-export function useAsObservable<T, K>(
-  value: T,
-  operator: (input: Observable<T>) => Observable<K>,
-): Observable<K>
-export function useAsObservable<T, K = T>(
-  value: T,
-  operator?: (input: Observable<T>) => Observable<K>,
-): Observable<T | K> {
-  const setup = useCallback((): [Observable<T | K>, BehaviorSubject<T>] => {
-    const subject = new BehaviorSubject(value)
-
-    const observable = subject.asObservable().pipe(distinctUntilChanged())
-    return [operator ? observable.pipe(operator) : observable, subject]
-  }, [])
-
-  const ref = useRef<[Observable<T | K>, BehaviorSubject<T>]>()
-
-  if (!ref.current) {
-    ref.current = setup()
-  }
-
-  const [observable] = ref.current
-
-  useEffect(() => {
-    if (!ref.current) {
-      return
-    }
-    const [, subject] = ref.current
-    subject.next(value)
-  }, [value, ref])
-
-  const shouldRestoreSubscriptionRef = useRef(false)
-  useEffect(() => {
-    if (shouldRestoreSubscriptionRef.current) {
-      if (!ref.current) {
-        ref.current = setup()
-      }
-      shouldRestoreSubscriptionRef.current = false
-    }
-
-    return () => {
-      if (!ref.current) {
-        return
-      }
-      // React StrictMode will call effects as `setup + teardown + setup` thus we can't trust this callback as "react is about to unmount"
-      // Tracking this ref lets us set the subscription back up on the next `setup` call if needed, and if it really did unmounted then all is well
-      shouldRestoreSubscriptionRef.current = true
-      const [, subject] = ref.current
-      subject.complete()
-      ref.current = undefined
-    }
-  }, [])
-  return observable
-}