@webkrafters/react-observable-context 5.0.0-rc.2 → 5.0.0-rc.3

package/package.json

@@ -54,8 +54,21 @@
     "typescript": "^5.4.5"
   },
   "files": [
-    "dist",
-    "logo.png"
+    "logo.png",
+    "dist/main/hooks/use-store/index.js",
+    "dist/main/hooks/use-store/index.d.ts",
+    "dist/main/hooks/use-render-key-provider/index.js",
+    "dist/main/hooks/use-render-key-provider/index.d.ts",
+    "dist/main/hooks/use-prehooks-ref/index.js",
+    "dist/main/hooks/use-prehooks-ref/index.d.ts",
+    "dist/model/storage/index.js",
+    "dist/model/storage/index.d.ts",
+    "dist/main/index.js",
+    "dist/main/index.d.ts",
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/constants.js",
+    "dist/constants.d.ts"
   ],
   "homepage": "https://eagleeye.js.org",
   "keywords": [
@@ -98,5 +111,5 @@
     "test:watch": "eslint --fix && jest --updateSnapshot --watchAll"
   },
   "types": "dist/index.d.ts",
-  "version": "5.0.0-rc.2"
-}
+  "version": "5.0.0-rc.3"
+}

package/dist/main/hooks/use-prehooks-ref/index.test.d.ts

@@ -1 +0,0 @@
-import '../../../test-artifacts/suppress-render-compat';

package/dist/main/hooks/use-prehooks-ref/index.test.js

@@ -1,21 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("@testing-library/react");
-require("../../../test-artifacts/suppress-render-compat");
-const _1 = __importDefault(require("."));
-describe('usePrehooksRef', () => {
-    test('retains prehooks prop in a `react-ref` object', () => {
-        const PREHOOK = 'PREHOOK_STUB';
-        const { result, rerender } = (0, react_1.renderHook)(_1.default, {
-            initialProps: PREHOOK
-        });
-        expect(result.current).toEqual({ current: PREHOOK });
-        const PREHOOK2 = 'PREHOOK2_STUB';
-        rerender(PREHOOK2);
-        expect(result.current).not.toEqual({ current: PREHOOK });
-        expect(result.current).toEqual({ current: PREHOOK2 });
-    });
-});

package/dist/main/hooks/use-render-key-provider/index.test.d.ts

@@ -1 +0,0 @@
-import '../../../test-artifacts/suppress-render-compat';

package/dist/main/hooks/use-render-key-provider/index.test.js

@@ -1,72 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const clone_total_1 = __importDefault(require("@webkrafters/clone-total"));
-const _1 = __importDefault(require("."));
-const react_1 = require("@testing-library/react");
-require("../../../test-artifacts/suppress-render-compat");
-describe('useRenderKeyProvider', () => {
-    let selectorMap;
-    beforeAll(() => { selectorMap = { _a: 'a', _b: 'b', _c: 'c' }; });
-    test('calculates new selectors for new selectorMap', () => {
-        const initialProps = (0, clone_total_1.default)(selectorMap);
-        const { result, rerender } = (0, react_1.renderHook)(_1.default, { initialProps });
-        const selectors = result.current;
-        const updateProps = { ...selectorMap, _y: 'y', _z: 'z' };
-        rerender(updateProps);
-        expect(result.current).toEqual(Object.values(updateProps));
-        expect(result.current).not.toEqual(selectors);
-        expect(result.current).not.toBe(selectors);
-    });
-    test('ensures no abrupt updates to selectors for new list with same selectorMap', () => {
-        const { result, rerender } = (0, react_1.renderHook)(_1.default, { initialProps: selectorMap });
-        const selectors = result.current;
-        rerender((0, clone_total_1.default)(selectorMap));
-        expect(result.current).toBe(selectors);
-    });
-    describe('productive call', () => {
-        let expected;
-        beforeAll(() => { expected = ['a', 'b', 'c']; });
-        test.each([
-            ['object', { _a: 'a', _b: 'b', _c: 'c' }],
-            ['array', ['a', 'b', 'c']]
-        ])('allows an %s type selectoMap', (label, value) => {
-            const { result } = (0, react_1.renderHook)(_1.default, { initialProps: value });
-            expect(result.current).toEqual(expected);
-        });
-    });
-    describe.each([
-        ['undefined', undefined],
-        ['null', null],
-        ['[]', []],
-        ['{}', {}]
-    ])('empty selectoMap = %s', (label, value) => {
-        test('returns empty renderKeys list', () => {
-            const { result } = (0, react_1.renderHook)(_1.default, { initialProps: value });
-            expect(result.current).toEqual([]);
-        });
-    });
-    describe.each([
-        ['string', 'abc'],
-        ['number', 22],
-        ['function', () => { }],
-        ['boolean', true],
-        ['Map', new Map()],
-        ['Set', new Set()],
-        ['Uint8Array', new Uint8Array()]
-    ])('incompatible selectorMap type = %s', (label, value) => {
-        test('throws Type error', () => {
-            try {
-                (0, react_1.renderHook)(_1.default, {
-                    initialProps: value
-                });
-            }
-            catch (e) {
-                expect(e.constructor.name).toEqual('TypeError');
-                expect(e.message).toEqual('Incompatible Selector Map type provided.');
-            }
-        });
-    });
-});

package/dist/main/hooks/use-store/index.test.d.ts

@@ -1 +0,0 @@
-import '../../../test-artifacts/suppress-render-compat';

package/dist/main/hooks/use-store/index.test.js

@@ -1,456 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const auto_immutable_1 = __importDefault(require("@webkrafters/auto-immutable"));
-const react_1 = require("@testing-library/react");
-require("../../../test-artifacts/suppress-render-compat");
-const constants_1 = require("../../../constants");
-const _1 = __importStar(require("."));
-const noop = () => { };
-beforeAll(() => { jest.spyOn(_1.deps, 'createStorageKey').mockReturnValue(expect.any(String)); });
-afterAll(jest.restoreAllMocks);
-describe('useStore', () => {
-    let initialState;
-    beforeAll(() => { initialState = { a: 1 }; });
-    describe('fundamentals', () => {
-        test('creates a store', () => {
-            const { result } = (0, react_1.renderHook)(({ prehooks: p, value: v }) => (0, _1.default)(p, v), {
-                initialProps: {
-                    prehooks: {},
-                    value: initialState
-                }
-            });
-            expect(result.current).toEqual(expect.objectContaining({
-                cache: expect.any(auto_immutable_1.default),
-                resetState: expect.any(Function),
-                setState: expect.any(Function),
-                subscribe: expect.any(Function)
-            }));
-        });
-        test('retains a clone of the initial state in storage', () => {
-            const clone = jest.fn().mockReturnValue(initialState);
-            const removeItem = noop;
-            const setItem = jest.fn();
-            (0, react_1.renderHook)(({ prehooks: p, value: v, storage: s }) => (0, _1.default)(p, v, s), {
-                initialProps: {
-                    prehooks: {},
-                    value: initialState,
-                    storage: { clone, getItem: () => { }, removeItem, setItem }
-                }
-            });
-            expect(clone).toHaveBeenCalledTimes(1);
-            expect(clone).toHaveBeenCalledWith(initialState);
-            expect(setItem).toHaveBeenCalledTimes(1);
-            expect(setItem.mock.calls[0][1]).toStrictEqual(initialState);
-        });
-        test('cleans up retained state from storage on store unmount if storage supported', () => {
-            const clone = v => v;
-            const setItem = noop;
-            const removeItem = jest.fn();
-            const { unmount } = (0, react_1.renderHook)(({ prehooks: p, value: v, storage: s }) => (0, _1.default)(p, v, s), {
-                initialProps: {
-                    prehooks: {},
-                    value: initialState,
-                    storage: { clone, getItem: () => { }, removeItem, setItem }
-                }
-            });
-            expect(removeItem).not.toHaveBeenCalled();
-            unmount();
-            expect(removeItem).toHaveBeenCalledTimes(1);
-        });
-        test('merges copies of subsequent value prop updates to state', async () => {
-            const setStateSpy = jest.fn();
-            const ConnectionMock = {
-                disconnect: noop,
-                set: setStateSpy
-            };
-            const ImmutableConnectSpy = jest
-                .spyOn(auto_immutable_1.default.prototype, 'connect')
-                .mockReturnValue(ConnectionMock);
-            const { rerender } = (0, react_1.renderHook)(({ prehooks: p, value: v }) => (0, _1.default)(p, v), {
-                initialProps: {
-                    prehooks: {},
-                    value: initialState
-                }
-            });
-            expect(setStateSpy).not.toHaveBeenCalled();
-            const updateState = { v: 3 };
-            rerender({ prehooks: {}, value: updateState });
-            expect(setStateSpy).toHaveBeenCalledTimes(1);
-            expect(setStateSpy.mock.calls[0][0]).toBe(updateState);
-            ImmutableConnectSpy.mockRestore();
-        });
-    });
-    describe('store', () => {
-        let storage;
-        beforeAll(() => {
-            storage = {
-                clone: jest.fn().mockReturnValue(initialState),
-                getItem: jest.fn().mockReturnValue(initialState),
-                removeItem: jest.fn(),
-                setItem: jest.fn()
-            };
-        });
-        describe('normal flow', () => {
-            let ConnectionMock, ImmutableConnectSpy, initialProps, prehooks, setAddSpy, setDeleteSpy, setStateSpy, store;
-            beforeAll(() => {
-                jest.clearAllMocks();
-                setStateSpy = jest.fn();
-                ConnectionMock = {
-                    disconnect: noop,
-                    get: expect.anything,
-                    set: setStateSpy
-                };
-                ImmutableConnectSpy = jest
-                    .spyOn(auto_immutable_1.default.prototype, 'connect')
-                    .mockReturnValue(ConnectionMock);
-                setAddSpy = jest.spyOn(Set.prototype, 'add');
-                setDeleteSpy = jest.spyOn(Set.prototype, 'delete');
-                prehooks = {
-                    resetState: jest.fn().mockReturnValue(true),
-                    setState: jest.fn().mockReturnValue(true)
-                };
-                initialProps = { prehooks, value: initialState, storage };
-                const { result } = (0, react_1.renderHook)(({ prehooks: p, storage: s, value: v }) => (0, _1.default)(p, v, s), { initialProps });
-                store = result.current;
-            });
-            afterAll(() => {
-                setAddSpy.mockRestore();
-                setDeleteSpy.mockRestore();
-                ImmutableConnectSpy.mockRestore();
-            });
-            describe('resetState', () => {
-                beforeAll(() => {
-                    prehooks.resetState.mockClear();
-                    setStateSpy.mockClear();
-                    storage.getItem.mockClear();
-                    store.resetState(ConnectionMock);
-                });
-                test('obtains initial state from storage', () => {
-                    expect(storage.getItem).toHaveBeenCalled();
-                });
-                test('runs the avaiable prehook', () => {
-                    expect(prehooks.resetState).toHaveBeenCalled();
-                });
-                test('resets the state if prehook evaluates to true', () => {
-                    // prehook.resetState had been mocked to return true
-                    // please see 'prehooks effects' describe block for alternate scenario
-                    expect(setStateSpy).toHaveBeenCalled();
-                });
-                describe('with no arguments', () => {
-                    test('runs the available prehook with an empty update data', () => {
-                        expect(prehooks.resetState.mock.calls[0][0]).toEqual({});
-                    });
-                    test('attempts to update current state with an empty update data', () => {
-                        expect(setStateSpy.mock.calls[0][0]).toEqual({});
-                    });
-                });
-                describe('with arguments', () => {
-                    let stateKey0, resetData;
-                    beforeAll(() => {
-                        prehooks.resetState.mockClear();
-                        setStateSpy.mockClear();
-                        stateKey0 = Object.keys(initialState)[0];
-                        resetData = { [stateKey0]: { [constants_1.REPLACE_TAG]: initialState[stateKey0] } };
-                        store.resetState(ConnectionMock, [stateKey0]);
-                    });
-                    test('runs the available prehook with update data corresponding to resetState argument', () => {
-                        expect(prehooks.resetState.mock.calls[0][0]).toEqual(resetData);
-                    });
-                    test('merges the update data into current state', () => {
-                        expect(setStateSpy.mock.calls[0][0]).toEqual(resetData);
-                    });
-                    describe('containing the `' + constants_1.FULL_STATE_SELECTOR + '` path', () => {
-                        let initialState, storageCloneMockImpl, storageGetItemMockImpl;
-                        beforeAll(() => {
-                            storageCloneMockImpl = storage.clone.getMockImplementation();
-                            storageGetItemMockImpl = storage.getItem.getMockImplementation();
-                            prehooks.resetState.mockClear();
-                            setStateSpy.mockClear();
-                            initialState = { ...initialState, b: { z: expect.anything() } };
-                            storage.clone.mockReset().mockReturnValue(initialState);
-                            storage.getItem.mockReset().mockReturnValue(initialState);
-                            const { result } = (0, react_1.renderHook)(({ prehooks: p, storage: s, value: v }) => (0, _1.default)(p, v, s), { initialProps: { prehooks, storage, value: initialState } });
-                            const store = result.current;
-                            store.resetState(ConnectionMock, ['a', constants_1.FULL_STATE_SELECTOR, 'b.z']);
-                        });
-                        afterAll(() => {
-                            storage.clone.mockReset().mockImplementation(storageCloneMockImpl);
-                            storage.getItem.mockReset().mockImplementation(storageGetItemMockImpl);
-                        });
-                        test('runs the available prehook with update data equaling the initial state', () => {
-                            expect(prehooks.resetState.mock.calls[0][0])
-                                .toEqual({ [constants_1.REPLACE_TAG]: initialState });
-                        });
-                        test('merges the initial state into current state', () => {
-                            expect(setStateSpy.mock.calls[0][0])
-                                .toEqual({ [constants_1.REPLACE_TAG]: initialState });
-                        });
-                    });
-                });
-                describe('path arguments not occurring in intial state', () => {
-                    let nonInitStatePaths, resetData;
-                    beforeAll(() => {
-                        prehooks.resetState.mockClear();
-                        setStateSpy.mockClear();
-                        nonInitStatePaths = [
-                            'a',
-                            'dsdfd.adfsdff',
-                            'dsdfd.sfgrwfg'
-                        ];
-                        resetData = {
-                            a: { [constants_1.REPLACE_TAG]: initialState.a },
-                            dsdfd: { [constants_1.DELETE_TAG]: ['adfsdff', 'sfgrwfg'] }
-                        };
-                        store.resetState(ConnectionMock, nonInitStatePaths);
-                    });
-                    test('are deleted from current state', () => {
-                        expect(setStateSpy.mock.calls[0][0]).toEqual(resetData);
-                    });
-                });
-                describe('with paths containing the `' + constants_1.FULL_STATE_SELECTOR + '` path where initial state is empty', () => {
-                    let storageCloneMockImpl, storageGetItemMockImpl;
-                    beforeAll(() => {
-                        storageCloneMockImpl = storage.clone.getMockImplementation();
-                        storageGetItemMockImpl = storage.getItem.getMockImplementation();
-                        prehooks.resetState.mockClear();
-                        setStateSpy.mockClear();
-                        storage.clone.mockReset().mockReturnValue();
-                        storage.getItem.mockReset().mockReturnValue();
-                        const { result } = (0, react_1.renderHook)(({ prehooks: p, storage: s }) => (0, _1.default)(p, undefined, s), { initialProps: { prehooks, storage } });
-                        const store = result.current;
-                        store.resetState(ConnectionMock, ['a', constants_1.FULL_STATE_SELECTOR, 'b.z']);
-                    });
-                    afterAll(() => {
-                        storage.clone.mockReset().mockImplementation(storageCloneMockImpl);
-                        storage.getItem.mockReset().mockImplementation(storageGetItemMockImpl);
-                    });
-                    test('empties the current state', () => {
-                        expect(setStateSpy.mock.calls[0][0]).toEqual(constants_1.CLEAR_TAG);
-                    });
-                });
-            });
-            describe('setState', () => {
-                describe('normal operations', () => {
-                    beforeAll(() => {
-                        prehooks.setState.mockClear();
-                        setStateSpy.mockClear();
-                        store.setState(ConnectionMock);
-                    });
-                    test('runs the avaiable prehook', () => {
-                        expect(prehooks.setState).toHaveBeenCalled();
-                    });
-                    test('sets the state if prehook evaluates to true', () => {
-                        // prehook.setState had been mocked to return true
-                        // please see 'prehooks effects' describe block for alternate scenario
-                        expect(setStateSpy).toHaveBeenCalled();
-                    });
-                });
-                describe('payload', () => {
-                    beforeEach(() => { setStateSpy.mockClear(); });
-                    test('can be a single change object', () => {
-                        const payload = { a: expect.anything() };
-                        store.setState(ConnectionMock, payload);
-                        expect(setStateSpy.mock.calls[0][0]).toEqual(payload);
-                    });
-                    test('can be an array of change objects', () => {
-                        const payload = [
-                            { a: expect.anything() },
-                            { x: expect.anything() }
-                        ];
-                        store.setState(ConnectionMock, payload);
-                        expect(setStateSpy.mock.calls[0][0]).toEqual(payload);
-                    });
-                });
-                describe('payload translation for compatibility with the cache', () => {
-                    beforeEach(() => { setStateSpy.mockClear(); });
-                    test('returns empty payload as-is', () => {
-                        store.setState(ConnectionMock);
-                        expect(setStateSpy.mock.calls[0][0]).toEqual(undefined);
-                        setStateSpy.mockClear();
-                        store.setState(ConnectionMock, null);
-                        expect(setStateSpy.mock.calls[0][0]).toEqual(null);
-                    });
-                    test('returns non top-level ' + constants_1.FULL_STATE_SELECTOR + ' key bearing payload as-is', () => {
-                        const payload = {
-                            a: expect.anything(),
-                            b: {
-                                [constants_1.FULL_STATE_SELECTOR]: expect.anything()
-                            }
-                        };
-                        store.setState(ConnectionMock, payload);
-                        expect(setStateSpy.mock.calls[0][0]).toEqual(payload);
-                    });
-                    test('converts all top-level' + constants_1.FULL_STATE_SELECTOR + ' payload keys only', () => {
-                        const asIsPayload = {
-                            a: expect.anything(),
-                            q: {
-                                [constants_1.FULL_STATE_SELECTOR]: expect.anything()
-                            }
-                        };
-                        store.setState(ConnectionMock, {
-                            [constants_1.FULL_STATE_SELECTOR]: expect.anything(),
-                            ...asIsPayload
-                        });
-                        expect(setStateSpy.mock.calls[0][0]).toEqual({
-                            [constants_1.GLOBAL_SELECTOR]: expect.anything(),
-                            ...asIsPayload
-                        });
-                    });
-                    test('converts any payload bearing top-level ' + constants_1.FULL_STATE_SELECTOR + ' keys amongst a payload list', () => {
-                        store.setState(ConnectionMock, [{
-                                [constants_1.FULL_STATE_SELECTOR]: expect.anything(),
-                                a: expect.anything()
-                            }, {
-                                a: expect.anything()
-                            }, {
-                                z: expect.anything(),
-                                k: expect.anything(),
-                                [constants_1.FULL_STATE_SELECTOR]: expect.anything(),
-                                a: expect.anything()
-                            }, {
-                                s: expect.anything(),
-                                t: {
-                                    [constants_1.FULL_STATE_SELECTOR]: expect.anything()
-                                }
-                            }, {
-                                l: [[constants_1.FULL_STATE_SELECTOR]],
-                                p: expect.anything()
-                            }]);
-                        expect(setStateSpy.mock.calls[0][0]).toEqual([{
-                                [constants_1.GLOBAL_SELECTOR]: expect.anything(),
-                                a: expect.anything()
-                            }, {
-                                a: expect.anything()
-                            }, {
-                                z: expect.anything(),
-                                k: expect.anything(),
-                                [constants_1.GLOBAL_SELECTOR]: expect.anything(),
-                                a: expect.anything()
-                            }, {
-                                s: expect.anything(),
-                                t: {
-                                    [constants_1.FULL_STATE_SELECTOR]: expect.anything()
-                                }
-                            }, {
-                                l: [[constants_1.FULL_STATE_SELECTOR]],
-                                p: expect.anything()
-                            }]);
-                    });
-                });
-            });
-            describe('subscribe', () => {
-                const LISTENER = 'LISTENER STUB';
-                let result;
-                beforeAll(() => {
-                    setAddSpy.mockClear();
-                    setDeleteSpy.mockClear();
-                    result = store.subscribe(LISTENER);
-                });
-                test('adds a new subscriber', () => {
-                    expect(setAddSpy).toHaveBeenCalled();
-                    expect(setAddSpy).toHaveBeenCalledWith(LISTENER);
-                });
-                test('returns a function to unsub the new subscriber', () => {
-                    expect(result).toBeInstanceOf(Function);
-                    expect(setDeleteSpy).not.toHaveBeenCalled();
-                    result();
-                    expect(setDeleteSpy).toHaveBeenCalledWith(LISTENER);
-                });
-            });
-        });
-        describe('prehooks effects', () => {
-            let ConnectionMock, ImmutableConnectSpy, setStateSpy, store;
-            beforeAll(() => {
-                jest.clearAllMocks();
-                setStateSpy = jest.fn();
-                ConnectionMock = {
-                    disconnect: noop,
-                    get: expect.anything,
-                    set: setStateSpy
-                };
-                ImmutableConnectSpy = jest
-                    .spyOn(auto_immutable_1.default.prototype, 'connect')
-                    .mockReturnValue(ConnectionMock);
-                store = (0, react_1.renderHook)(({ prehooks: p, storage: s, value: v }) => (0, _1.default)(p, v, s), {
-                    initialProps: {
-                        prehooks: {
-                            resetState: jest.fn().mockReturnValue(false),
-                            setState: jest.fn().mockReturnValue(false)
-                        },
-                        storage,
-                        value: initialState
-                    }
-                }).result.current;
-            });
-            afterAll(() => { ImmutableConnectSpy.mockRestore(); });
-            describe('resetState #2', () => {
-                test('will not reset the state if prehook evaluates to false', () => {
-                    // prehooks.resetState had been mocked to return false
-                    store.resetState(ConnectionMock);
-                    expect(setStateSpy).not.toHaveBeenCalled();
-                });
-                test('throws if return type is not boolean', () => {
-                    const { result } = (0, react_1.renderHook)(({ prehooks: p, storage: s, value: v }) => (0, _1.default)(p, v, s), {
-                        initialProps: {
-                            prehooks: {
-                                resetState: noop,
-                                setState: () => true
-                            },
-                            storage,
-                            value: initialState
-                        }
-                    });
-                    expect(() => result.current.resetState(ConnectionMock, expect.anything()))
-                        .toThrow('`resetState` prehook must return a boolean value.');
-                });
-            });
-            describe('setState #2', () => {
-                test('will not set the state if prehook evaluates to false', () => {
-                    // prehooks.setState had been mocked to return false
-                    store.setState();
-                    expect(setStateSpy).not.toHaveBeenCalled();
-                });
-                test('throws if return type is not boolean', () => {
-                    const { result } = (0, react_1.renderHook)(({ prehooks: p, storage: s, value: v }) => (0, _1.default)(p, v, s), {
-                        initialProps: {
-                            prehooks: {
-                                resetState: () => true,
-                                setState: noop
-                            },
-                            storage,
-                            value: initialState
-                        }
-                    });
-                    expect(() => result.current.setState(ConnectionMock, expect.anything()))
-                        .toThrow('`setState` prehook must return a boolean value.');
-                });
-            });
-        });
-    });
-});

package/dist/main/index.test.d.ts

@@ -1,11 +0,0 @@
-import '@testing-library/jest-dom';
-/**
- * @typedef {import('@testing-library/react-hooks').Renderer<TProps>} Renderer
- * @template TProps
- */
-/**
- * 	@typedef {import('@testing-library/react-hooks').RenderHookResult<TProps, TValue, TRenderer>} RenderHookResult
- *	@template TProps
- *	@template TValue
- *	@template {Renderer<TProps>} TRenderer
- */