react-rx 3.0.0-4 → 3.0.0-6

package/dist/cjs/useObservable.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useObservable = void 0;
-var react_1 = require("react");
-var operators_1 = require("rxjs/operators");
-function getValue(value) {
-    return typeof value === 'function' ? value() : value;
-}
-var cache = new WeakMap();
-function useObservable(observable, initialValue) {
-    /**
-     * Store the initialValue in a ref, as we don't want a changed `initialValue` to trigger a re-subscription.
-     * But we also don't want the initialValue to be stale if the observable changes.
-     */
-    var initialValueRef = (0, react_1.useRef)(getValue(initialValue));
-    /**
-     * Ensures that the initialValue is always up-to-date in case the observable changes.
-     */
-    (0, react_1.useEffect)(function () {
-        initialValueRef.current = getValue(initialValue);
-    }, [initialValue]);
-    var store = (0, react_1.useMemo)(function () {
-        if (!cache.has(observable)) {
-            var entry_1 = {
-                snapshot: initialValueRef.current,
-            };
-            entry_1.observable = observable.pipe((0, operators_1.shareReplay)({ refCount: true, bufferSize: 1 }), (0, operators_1.tap)(function (value) { return (entry_1.snapshot = value); }));
-            // Eagerly subscribe to sync set `entry.currentValue` to what the observable returns, and keep the observable alive until the component unmounts.
-            entry_1.subscription = entry_1.observable.subscribe();
-            cache.set(observable, entry_1);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        var instance = cache.get(observable);
-        if (instance.subscription.closed) {
-            instance.subscription = instance.observable.subscribe();
-        }
-        return {
-            subscribe: function (onStoreChange) {
-                var subscription = instance.observable.subscribe(onStoreChange);
-                instance.subscription.unsubscribe();
-                return function () { return subscription.unsubscribe(); };
-            },
-            getSnapshot: function () { return instance.snapshot; },
-        };
-    }, [observable]);
-    return (0, react_1.useSyncExternalStore)(store.subscribe, store.getSnapshot);
-}
-exports.useObservable = useObservable;

package/dist/cjs/useObservableEvent.d.ts

@@ -1,8 +0,0 @@
-import { DependencyList } from 'react';
-import { Observable } from 'rxjs';
-export declare function useObservableCallback<T, U>(fn: (arg: Observable<T>) => Observable<U>, dependencies?: DependencyList): (arg: T) => void;
-export declare function useObservableEvent<T, U>(fn: (arg: Observable<T>) => Observable<U>): (arg: T) => void;
-/**
- * This is a ponyfill of the upcoming `useEffectEvent` hook that'll arrive in React 19
- */
-export declare function useEffectEvent<const T extends (...args: any[]) => void>(fn: T): T;

package/dist/cjs/useObservableEvent.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useEffectEvent = exports.useObservableEvent = exports.useObservableCallback = void 0;
-var observable_callback_1 = require("observable-callback");
-var react_1 = require("react");
-var EMPTY_DEPS = [];
-function useObservableCallback(fn, dependencies) {
-    if (dependencies === void 0) { dependencies = EMPTY_DEPS; }
-    var callbackRef = (0, react_1.useRef)();
-    if (!callbackRef.current) {
-        callbackRef.current = (0, observable_callback_1.observableCallback)();
-    }
-    var _a = callbackRef.current, calls$ = _a[0], call = _a[1];
-    var callback = (0, react_1.useCallback)(fn, dependencies);
-    (0, react_1.useEffect)(function () {
-        var subscription = calls$.pipe(callback).subscribe();
-        return function () {
-            subscription.unsubscribe();
-        };
-    }, [calls$, call, callback]);
-    return call;
-}
-exports.useObservableCallback = useObservableCallback;
-function useObservableEvent(fn) {
-    var _a = (0, react_1.useState)(function () { return (0, observable_callback_1.observableCallback)(); })[0], calls$ = _a[0], call = _a[1];
-    var callback = useEffectEvent(fn);
-    (0, react_1.useEffect)(function () {
-        var subscription = calls$.pipe(callback).subscribe();
-        return function () { return subscription.unsubscribe(); };
-    }, [callback, calls$]);
-    return call;
-}
-exports.useObservableEvent = useObservableEvent;
-/**
- * This is a ponyfill of the upcoming `useEffectEvent` hook that'll arrive in React 19
- */
-function useEffectEvent(fn) {
-    var ref = (0, react_1.useRef)(null);
-    (0, react_1.useInsertionEffect)(function () {
-        ref.current = fn;
-    }, [fn]);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (0, react_1.useCallback)(function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var f = ref.current;
-        return f.apply(void 0, args);
-    }, []);
-}
-exports.useEffectEvent = useEffectEvent;

package/dist/es2015/__tests__/strictmode.test.d.ts

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

package/dist/es2015/__tests__/strictmode.test.js

@@ -1,58 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { act, render } from '@testing-library/react';
-import { createElement, Fragment, StrictMode, useEffect } from 'react';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { useObservable } from '../useObservable';
-const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-// NOTE: Jest runs NODE_ENV=test by default, which enables development flags for React
-test('Strict mode should trigger double mount effects and re-renders', () => __awaiter(void 0, void 0, void 0, function* () {
-    const subject = new BehaviorSubject(0);
-    const observable = subject.asObservable();
-    const returnedValues = [];
-    let mountCount = 0;
-    function ObservableComponent() {
-        useEffect(() => {
-            mountCount++;
-        }, []);
-        const observedValue = useObservable(observable);
-        returnedValues.push(observedValue);
-        return createElement(Fragment, null, observedValue);
-    }
-    render(createElement(StrictMode, null, createElement(ObservableComponent)));
-    expect(mountCount).toEqual(2);
-    expect(returnedValues).toEqual([0, 0]);
-    yield wait(10);
-    act(() => subject.next(1));
-    expect(returnedValues).toEqual([0, 0, 1, 1]);
-    act(() => subject.next(2));
-    expect(returnedValues).toEqual([0, 0, 1, 1, 2, 2]);
-    expect(mountCount).toEqual(2);
-}));
-test('Strict mode should unsubscribe the source observable on unmount', () => {
-    const subscribed = [];
-    const unsubscribed = [];
-    let nextId = 0;
-    const observable = new Observable(() => {
-        const id = nextId++;
-        subscribed.push(id);
-        return () => {
-            unsubscribed.push(id);
-        };
-    });
-    function ObservableComponent() {
-        useObservable(observable);
-        return createElement(Fragment, null);
-    }
-    const { rerender } = render(createElement(StrictMode, null, createElement(ObservableComponent)));
-    expect(subscribed).toEqual([0, 1]);
-    rerender(createElement(StrictMode, null, createElement('div')));
-    expect(unsubscribed).toEqual([0, 1]);
-});

package/dist/es2015/__tests__/useObservable.test.d.ts

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

package/dist/es2015/__tests__/useObservable.test.js

@@ -1,110 +0,0 @@
-import { act, render, renderHook } from '@testing-library/react';
-import { createElement, Fragment } from 'react';
-import { asyncScheduler, Observable, of, scheduled, Subject, timer } from 'rxjs';
-import { mapTo } from 'rxjs/operators';
-import { useObservable } from '../useObservable';
-test('should subscribe immediately on component mount and unsubscribe on component unmount', () => {
-    let subscribed = false;
-    const observable = new Observable(() => {
-        subscribed = true;
-        return () => {
-            subscribed = false;
-        };
-    });
-    expect(subscribed).toBe(false);
-    const { unmount } = renderHook(() => useObservable(observable));
-    expect(subscribed).toBe(true);
-    unmount();
-    expect(subscribed).toBe(false);
-});
-test('should only subscribe once when given same observable on re-renders', () => {
-    let subscriptionCount = 0;
-    const observable = new Observable(() => {
-        subscriptionCount++;
-    });
-    expect(subscriptionCount).toBe(0);
-    const { unmount, rerender } = renderHook(() => useObservable(observable));
-    expect(subscriptionCount).toBe(1);
-    rerender();
-    expect(subscriptionCount).toBe(1);
-    unmount();
-    renderHook(() => useObservable(observable));
-    expect(subscriptionCount).toBe(2);
-});
-test('should not return undefined during render if initial value is given', () => {
-    const observable = timer(100).pipe(mapTo('emitted value'));
-    const returnedValues = [];
-    function ObservableComponent() {
-        const observedValue = useObservable(observable, 'initial value');
-        returnedValues.push(observedValue);
-        return createElement(Fragment, null, observedValue);
-    }
-    render(createElement(ObservableComponent));
-    expect(returnedValues).toEqual(expect.arrayContaining(['initial value']));
-});
-test('should not return undefined during render if observable is sync', () => {
-    const observable = of('initial value');
-    const returnedValues = [];
-    function ObservableComponent() {
-        const observedValue = useObservable(observable);
-        returnedValues.push(observedValue);
-        return createElement(Fragment, null, observedValue);
-    }
-    render(createElement(ObservableComponent));
-    expect(returnedValues).toEqual(expect.arrayContaining(['initial value']));
-});
-test('should return undefined during first render if observable is async', () => {
-    const observable = scheduled('async value', asyncScheduler);
-    const returnedValues = [];
-    function ObservableComponent() {
-        const observedValue = useObservable(observable);
-        returnedValues.push(observedValue);
-        return createElement(Fragment, null, observedValue);
-    }
-    render(createElement(ObservableComponent));
-    expect(returnedValues).toEqual(expect.arrayContaining([undefined]));
-});
-test('should have sync values from an observable as initial value', () => {
-    const observable = of('something sync');
-    const { result } = renderHook(() => useObservable(observable));
-    expect(result.current).toBe('something sync');
-});
-test('should have undefined as initial value from delayed observables', () => {
-    const { result, unmount } = renderHook(() => useObservable(scheduled('something async', asyncScheduler)));
-    expect(result.current).toBeUndefined();
-    unmount();
-});
-test('should have passed initialValue as initial value from delayed observables', () => {
-    const { result, unmount } = renderHook(() => useObservable(scheduled('something async', asyncScheduler), 'initial'));
-    expect(result.current).toBe('initial');
-    unmount();
-});
-test('should update with values from observables', () => {
-    const values$ = new Subject();
-    const { result, unmount } = renderHook(() => useObservable(values$));
-    expect(result.current).toBe(undefined);
-    act(() => values$.next('something'));
-    expect(result.current).toBe('something');
-    act(() => values$.next('otherthing'));
-    expect(result.current).toBe('otherthing');
-    unmount();
-});
-test('should re-subscribe when receiving a new observable', () => {
-    const first$ = new Subject();
-    const second$ = new Subject();
-    let current$ = first$;
-    const { result, rerender, unmount } = renderHook(() => useObservable(current$, '!!initial!!'));
-    act(() => first$.next('first 1'));
-    expect(result.current).toBe('first 1');
-    current$ = second$;
-    rerender();
-    // since observable #2 hasn't emitted a value yet, we should use the initial value
-    expect(result.current).toBe('!!initial!!');
-    // Now we should be subscribed to second$ and it's emission should be returned
-    act(() => second$.next('second 1'));
-    expect(result.current).toBe('second 1');
-    // we should no longer be subscribed to the first and ignore any emissions
-    act(() => first$.next('first 2'));
-    expect(result.current).toBe('second 1');
-    unmount();
-});

package/dist/es2015/index.d.ts

@@ -1,2 +0,0 @@
-export * from './useObservable';
-export * from './useObservableEvent';

package/dist/es2015/index.js

@@ -1,2 +0,0 @@
-export * from './useObservable';
-export * from './useObservableEvent';

package/dist/es2015/useObservable.d.ts

@@ -1,4 +0,0 @@
-import type { Observable } from 'rxjs';
-export declare function useObservable<ObservableType extends Observable<any>>(observable: ObservableType, initialValue?: UnboxObservable<ObservableType> | (() => UnboxObservable<ObservableType>)): UnboxObservable<ObservableType>;
-type UnboxObservable<T> = T extends Observable<infer U> ? U : never;
-export {};

package/dist/es2015/useObservable.js

@@ -1,44 +0,0 @@
-import { useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
-import { shareReplay, tap } from 'rxjs/operators';
-function getValue(value) {
-    return typeof value === 'function' ? value() : value;
-}
-const cache = new WeakMap();
-export function useObservable(observable, initialValue) {
-    /**
-     * Store the initialValue in a ref, as we don't want a changed `initialValue` to trigger a re-subscription.
-     * But we also don't want the initialValue to be stale if the observable changes.
-     */
-    const initialValueRef = useRef(getValue(initialValue));
-    /**
-     * Ensures that the initialValue is always up-to-date in case the observable changes.
-     */
-    useEffect(() => {
-        initialValueRef.current = getValue(initialValue);
-    }, [initialValue]);
-    const store = useMemo(() => {
-        if (!cache.has(observable)) {
-            const entry = {
-                snapshot: initialValueRef.current,
-            };
-            entry.observable = observable.pipe(shareReplay({ refCount: true, bufferSize: 1 }), tap((value) => (entry.snapshot = value)));
-            // Eagerly subscribe to sync set `entry.currentValue` to what the observable returns, and keep the observable alive until the component unmounts.
-            entry.subscription = entry.observable.subscribe();
-            cache.set(observable, entry);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const instance = cache.get(observable);
-        if (instance.subscription.closed) {
-            instance.subscription = instance.observable.subscribe();
-        }
-        return {
-            subscribe: (onStoreChange) => {
-                const subscription = instance.observable.subscribe(onStoreChange);
-                instance.subscription.unsubscribe();
-                return () => subscription.unsubscribe();
-            },
-            getSnapshot: () => instance.snapshot,
-        };
-    }, [observable]);
-    return useSyncExternalStore(store.subscribe, store.getSnapshot);
-}

package/dist/es2015/useObservableEvent.d.ts

@@ -1,8 +0,0 @@
-import { DependencyList } from 'react';
-import { Observable } from 'rxjs';
-export declare function useObservableCallback<T, U>(fn: (arg: Observable<T>) => Observable<U>, dependencies?: DependencyList): (arg: T) => void;
-export declare function useObservableEvent<T, U>(fn: (arg: Observable<T>) => Observable<U>): (arg: T) => void;
-/**
- * This is a ponyfill of the upcoming `useEffectEvent` hook that'll arrive in React 19
- */
-export declare function useEffectEvent<const T extends (...args: any[]) => void>(fn: T): T;

package/dist/es2015/useObservableEvent.js

@@ -1,41 +0,0 @@
-import { observableCallback } from 'observable-callback';
-import { useCallback, useEffect, useInsertionEffect, useRef, useState } from 'react';
-const EMPTY_DEPS = [];
-export function useObservableCallback(fn, dependencies = EMPTY_DEPS) {
-    const callbackRef = useRef();
-    if (!callbackRef.current) {
-        callbackRef.current = observableCallback();
-    }
-    const [calls$, call] = callbackRef.current;
-    const callback = useCallback(fn, dependencies);
-    useEffect(() => {
-        const subscription = calls$.pipe(callback).subscribe();
-        return () => {
-            subscription.unsubscribe();
-        };
-    }, [calls$, call, callback]);
-    return call;
-}
-export function useObservableEvent(fn) {
-    const [[calls$, call]] = useState(() => observableCallback());
-    const callback = useEffectEvent(fn);
-    useEffect(() => {
-        const subscription = calls$.pipe(callback).subscribe();
-        return () => subscription.unsubscribe();
-    }, [callback, calls$]);
-    return call;
-}
-/**
- * This is a ponyfill of the upcoming `useEffectEvent` hook that'll arrive in React 19
- */
-export function useEffectEvent(fn) {
-    const ref = useRef(null);
-    useInsertionEffect(() => {
-        ref.current = fn;
-    }, [fn]);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return useCallback((...args) => {
-        const f = ref.current;
-        return f(...args);
-    }, []);
-}

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

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

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

@@ -1,94 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import { act, render } from '@testing-library/react';
-import { createElement, Fragment, StrictMode, useEffect } from 'react';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { useObservable } from '../useObservable';
-var wait = function (ms) { return new Promise(function (resolve) { return setTimeout(resolve, ms); }); };
-// NOTE: Jest runs NODE_ENV=test by default, which enables development flags for React
-test('Strict mode should trigger double mount effects and re-renders', function () { return __awaiter(void 0, void 0, void 0, function () {
-    function ObservableComponent() {
-        useEffect(function () {
-            mountCount++;
-        }, []);
-        var observedValue = useObservable(observable);
-        returnedValues.push(observedValue);
-        return createElement(Fragment, null, observedValue);
-    }
-    var subject, observable, returnedValues, mountCount;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                subject = new BehaviorSubject(0);
-                observable = subject.asObservable();
-                returnedValues = [];
-                mountCount = 0;
-                render(createElement(StrictMode, null, createElement(ObservableComponent)));
-                expect(mountCount).toEqual(2);
-                expect(returnedValues).toEqual([0, 0]);
-                return [4 /*yield*/, wait(10)];
-            case 1:
-                _a.sent();
-                act(function () { return subject.next(1); });
-                expect(returnedValues).toEqual([0, 0, 1, 1]);
-                act(function () { return subject.next(2); });
-                expect(returnedValues).toEqual([0, 0, 1, 1, 2, 2]);
-                expect(mountCount).toEqual(2);
-                return [2 /*return*/];
-        }
-    });
-}); });
-test('Strict mode should unsubscribe the source observable on unmount', function () {
-    var subscribed = [];
-    var unsubscribed = [];
-    var nextId = 0;
-    var observable = new Observable(function () {
-        var id = nextId++;
-        subscribed.push(id);
-        return function () {
-            unsubscribed.push(id);
-        };
-    });
-    function ObservableComponent() {
-        useObservable(observable);
-        return createElement(Fragment, null);
-    }
-    var rerender = render(createElement(StrictMode, null, createElement(ObservableComponent))).rerender;
-    expect(subscribed).toEqual([0, 1]);
-    rerender(createElement(StrictMode, null, createElement('div')));
-    expect(unsubscribed).toEqual([0, 1]);
-});

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

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

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

@@ -1,114 +0,0 @@
-import { act, render, renderHook } from '@testing-library/react';
-import { createElement, Fragment } from 'react';
-import { asyncScheduler, Observable, of, scheduled, Subject, timer } from 'rxjs';
-import { mapTo } from 'rxjs/operators';
-import { useObservable } from '../useObservable';
-test('should subscribe immediately on component mount and unsubscribe on component unmount', function () {
-    var subscribed = false;
-    var observable = new Observable(function () {
-        subscribed = true;
-        return function () {
-            subscribed = false;
-        };
-    });
-    expect(subscribed).toBe(false);
-    var unmount = renderHook(function () { return useObservable(observable); }).unmount;
-    expect(subscribed).toBe(true);
-    unmount();
-    expect(subscribed).toBe(false);
-});
-test('should only subscribe once when given same observable on re-renders', function () {
-    var subscriptionCount = 0;
-    var observable = new Observable(function () {
-        subscriptionCount++;
-    });
-    expect(subscriptionCount).toBe(0);
-    var _a = renderHook(function () { return useObservable(observable); }), unmount = _a.unmount, rerender = _a.rerender;
-    expect(subscriptionCount).toBe(1);
-    rerender();
-    expect(subscriptionCount).toBe(1);
-    unmount();
-    renderHook(function () { return useObservable(observable); });
-    expect(subscriptionCount).toBe(2);
-});
-test('should not return undefined during render if initial value is given', function () {
-    var observable = timer(100).pipe(mapTo('emitted value'));
-    var returnedValues = [];
-    function ObservableComponent() {
-        var observedValue = useObservable(observable, 'initial value');
-        returnedValues.push(observedValue);
-        return createElement(Fragment, null, observedValue);
-    }
-    render(createElement(ObservableComponent));
-    expect(returnedValues).toEqual(expect.arrayContaining(['initial value']));
-});
-test('should not return undefined during render if observable is sync', function () {
-    var observable = of('initial value');
-    var returnedValues = [];
-    function ObservableComponent() {
-        var observedValue = useObservable(observable);
-        returnedValues.push(observedValue);
-        return createElement(Fragment, null, observedValue);
-    }
-    render(createElement(ObservableComponent));
-    expect(returnedValues).toEqual(expect.arrayContaining(['initial value']));
-});
-test('should return undefined during first render if observable is async', function () {
-    var observable = scheduled('async value', asyncScheduler);
-    var returnedValues = [];
-    function ObservableComponent() {
-        var observedValue = useObservable(observable);
-        returnedValues.push(observedValue);
-        return createElement(Fragment, null, observedValue);
-    }
-    render(createElement(ObservableComponent));
-    expect(returnedValues).toEqual(expect.arrayContaining([undefined]));
-});
-test('should have sync values from an observable as initial value', function () {
-    var observable = of('something sync');
-    var result = renderHook(function () { return useObservable(observable); }).result;
-    expect(result.current).toBe('something sync');
-});
-test('should have undefined as initial value from delayed observables', function () {
-    var _a = renderHook(function () {
-        return useObservable(scheduled('something async', asyncScheduler));
-    }), result = _a.result, unmount = _a.unmount;
-    expect(result.current).toBeUndefined();
-    unmount();
-});
-test('should have passed initialValue as initial value from delayed observables', function () {
-    var _a = renderHook(function () {
-        return useObservable(scheduled('something async', asyncScheduler), 'initial');
-    }), result = _a.result, unmount = _a.unmount;
-    expect(result.current).toBe('initial');
-    unmount();
-});
-test('should update with values from observables', function () {
-    var values$ = new Subject();
-    var _a = renderHook(function () { return useObservable(values$); }), result = _a.result, unmount = _a.unmount;
-    expect(result.current).toBe(undefined);
-    act(function () { return values$.next('something'); });
-    expect(result.current).toBe('something');
-    act(function () { return values$.next('otherthing'); });
-    expect(result.current).toBe('otherthing');
-    unmount();
-});
-test('should re-subscribe when receiving a new observable', function () {
-    var first$ = new Subject();
-    var second$ = new Subject();
-    var current$ = first$;
-    var _a = renderHook(function () { return useObservable(current$, '!!initial!!'); }), result = _a.result, rerender = _a.rerender, unmount = _a.unmount;
-    act(function () { return first$.next('first 1'); });
-    expect(result.current).toBe('first 1');
-    current$ = second$;
-    rerender();
-    // since observable #2 hasn't emitted a value yet, we should use the initial value
-    expect(result.current).toBe('!!initial!!');
-    // Now we should be subscribed to second$ and it's emission should be returned
-    act(function () { return second$.next('second 1'); });
-    expect(result.current).toBe('second 1');
-    // we should no longer be subscribed to the first and ignore any emissions
-    act(function () { return first$.next('first 2'); });
-    expect(result.current).toBe('second 1');
-    unmount();
-});

package/dist/esm/index.d.ts

@@ -1,2 +0,0 @@
-export * from './useObservable';
-export * from './useObservableEvent';

package/dist/esm/index.js

@@ -1,2 +0,0 @@
-export * from './useObservable';
-export * from './useObservableEvent';

package/dist/esm/useObservable.d.ts

@@ -1,4 +0,0 @@
-import type { Observable } from 'rxjs';
-export declare function useObservable<ObservableType extends Observable<any>>(observable: ObservableType, initialValue?: UnboxObservable<ObservableType> | (() => UnboxObservable<ObservableType>)): UnboxObservable<ObservableType>;
-type UnboxObservable<T> = T extends Observable<infer U> ? U : never;
-export {};