@webkrafters/react-observable-context 4.7.7 → 5.0.0-rc.1

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

@@ -0,0 +1,456 @@
+"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.d.ts

@@ -1,19 +1,13 @@
-/**
- * @returns {ObservableContext<T>} Refers to the IObservableContext<T> type of the ObservableContext<T>
- * @template {State} T
- * @see {ObservableContext<T>}
- */
-export function createContext<T extends import("../types").State>(): ObservableContext<T, BaseSelectorMap<T>>;
-
+import type { ComponentType, NamedExoticComponent } from 'react';
+import type { ConnectedComponent, ConnectProps, InjectedProps, ObservableContext, PropsExtract, SelectorMap, State, Store } from '..';
+export declare function createContext<T extends State = State>(): ObservableContext<T>;
 /**
  * Actively monitors the store and triggers component re-render if any of the watched keys in the state objects changes
  *
- * @param {ObservableContext<STATE, SELECTOR_MAP>} context Refers to the PublicObservableContext<T> type of the ObservableContext<T>
- * @param {SELECTOR_MAP} [selectorMap = {}] Key:value pairs where `key` => arbitrary key given to a Store.data property holding a state slice and `value` => property path to a state slice used by this component: see examples below. May add a mapping for a certain arbitrary key='state' and value='@@STATE' to indicate a desire to obtain the entire state object and assign to a `state` property of Store.data. A change in any of the referenced properties results in this component render. When using '@@STATE', note that any change within the state object will result in this component render.
- * @returns {Store<STATE, SELECTOR_MAP>}
- * @template {State} STATE
- * @template {SelectorMap<STATE>} [SELECTOR_MAP=SelectorMap<STATE>]
+ * @param context - Refers to the PublicObservableContext<T> type of the ObservableContext<T>
+ * @param [selectorMap = {}] - Key:value pairs where `key` => arbitrary key given to a Store.data property holding a state slice and `value` => property path to a state slice used by this component: see examples below. May add a mapping for a certain arbitrary key='state' and value='@@STATE' to indicate a desire to obtain the entire state object and assign to a `state` property of Store.data. A change in any of the referenced properties results in this component render. When using '@@STATE', note that any change within the state object will result in this component render.
  * @see {ObservableContext<STATE,SELECTOR_MAP>}
+ *
  * @example
  * a valid property path follows the `lodash` object property path convention.
  * for a state = { a: 1, b: 2, c: 3, d: { e: 5, f: [6, { x: 7, y: 8, z: 9 } ] } }
@@ -35,139 +29,16 @@ export function createContext<T extends import("../types").State>(): ObservableC
  * {myX: 'd.e.f[1].x'} or {myX: 'd.e.f.1.x'} => {myX: 7} // same applies to {myY: 'd.e.f[1].y'} = {myY: 8}; {myZ: 'd.e.f[1].z'} = {myZ: 9}
  * {myData: '@@STATE'} => {myData: state}
  */
-export function useContext<STATE extends import("../types").State, SELECTOR_MAP extends BaseSelectorMap<STATE> = BaseSelectorMap<STATE>>(context: ObservableContext<STATE, SELECTOR_MAP>, selectorMap?: SELECTOR_MAP): Store<STATE, SELECTOR_MAP>;
-
+export declare function useContext<STATE extends State, SELECTOR_MAP extends SelectorMap>(context: ObservableContext<STATE>, selectorMap?: SELECTOR_MAP): Store<STATE, SELECTOR_MAP>;
 /**
  * Provides an HOC function for connecting its WrappedComponent argument to the context store.
  *
  * The HOC function automatically memoizes any un-memoized WrappedComponent argument.
  *
- * @param {ObservableContext<STATE, SELECTOR_MAP>} context - Refers to the PublicObservableContext<T> type of the ObservableContext<T>
- * @param {SELECTOR_MAP} [selectorMap] - Key:value pairs where `key` => arbitrary key given to a Store.data property holding a state slice and `value` => property path to a state slice used by this component: see examples below. May add a mapping for a certain arbitrary key='state' and value='@@STATE' to indicate a desire to obtain the entire state object and assign to a `state` property of Store.data. A change in any of the referenced properties results in this component render. When using '@@STATE', note that any change within the state object will result in this component render.
- * @returns {(WrappedComponent: C) => ConnectedComponent<OWNPROPS, Store<STATE, SELECTOR_MAP>>} - Connector HOC function
- * @template {State} STATE
- * @template {OwnProps<State>} [OWNPROPS=OwnProps]
- * @template {SelectorMap<STATE>} [SELECTOR_MAP=SelectorMap<STATE>]
- * @template {ComponentType<ConnectedComponentProps<OWNPROPS, PartialStore<STATE, SELECTOR_MAP>>>|ExoticComponent<ConnectedComponentProps<OWNPROPS, PartialStore<STATE, SELECTOR_MAP>>>} [C = ComponentType<ConnectedComponentProps<OWNPROPS, PartialStore<STATE, SELECTOR_MAP>>>]
- * @see {ObservableContext<STATE,SELECTOR_MAP>}
+ * @param context - Refers to the PublicObservableContext<T> type of the ObservableContext<T>
+ * @param [selectorMap] - Key:value pairs where `key` => arbitrary key given to a Store.data property holding a state slice and `value` => property path to a state slice used by this component: see examples below. May add a mapping for a certain arbitrary key='state' and value='@@STATE' to indicate a desire to obtain the entire state object and assign to a `state` property of Store.data. A change in any of the referenced properties results in this component render. When using '@@STATE', note that any change within the state object will result in this component render.
  * @see {useContext} for selectorMap sample
  */
-export function connect<STATE extends import("../types").State, OWNPROPS extends Pick<import("../types").State, keyof import("../types").State> & {
-    ref?: unknown;
-} = {}, SELECTOR_MAP extends BaseSelectorMap<STATE> = BaseSelectorMap<STATE>, C extends ComponentType<ConnectedComponentProps<OWNPROPS, PartialStore<STATE, SELECTOR_MAP>>> | import("react").ExoticComponent<ComponentType<ConnectedComponentProps<OWNPROPS, PartialStore<STATE, SELECTOR_MAP>>>> = ComponentType<ConnectedComponentProps<OWNPROPS, PartialStore<STATE, SELECTOR_MAP>>>>(context: ObservableContext<STATE, SELECTOR_MAP>, selectorMap?: SELECTOR_MAP): (WrappedComponent: C) => ConnectedComponent<OWNPROPS, Store<STATE, SELECTOR_MAP>>;
-export type CLEAR_TAG = typeof CLEAR_TAG;
-
-/** @example changes = { property: CLEAR_TAG } */
-export const CLEAR_TAG: "@@CLEAR";
-export type DELETE_TAG = typeof DELETE_TAG;
-
-/**
- * @example
- * changes = {
- * 	property: {
- * 		[DELETE_TAG]: [keys/indexes to remove from property]
- * 	}
- * }
- */
-export const DELETE_TAG: "@@DELETE";
-export type FULL_STATE_SELECTOR = import("../types").FULL_STATE_SELECTOR;
-export const FULL_STATE_SELECTOR: "@@STATE";
-export type MOVE_TAG = typeof MOVE_TAG;
-
-/**
- * @example
- * changes = {
- * 	arrayProperty: {
- * 		[MOVE_TAG]: [-/+fromIndex, -/+toIndex, +numItems?] // numItems = 1 by default
- * 	}
- * }
- */
-export const MOVE_TAG: "@@MOVE";
-export type PUSH_TAG = typeof PUSH_TAG;
-
-/** @example changes = { arrayProperty: { [PUSH_TAG]: [new items to append to array] } } */
-export const PUSH_TAG: "@@PUSH";
-export type REPLACE_TAG = typeof REPLACE_TAG;
-
-/** @example changes = { property: { [REPLACE_TAG]: replacement } } */
-export const REPLACE_TAG: "@@REPLACE";
-export type SET_TAG = typeof SET_TAG;
-
-/**
- * @example
- * changes = {
- * 	property: {
- * 		[SET_TAG]: replacement // or a compute replacement function (i.e. currentProperty => replacement)
- * 	}
- * }
- */
-export const SET_TAG: "@@SET";
-export type SPLICE_TAG = typeof SPLICE_TAG;
-
-/**
- * @example
- * changes = {
- *   arrayProperty: {
- *     [SPLICE_TAG]: [-/+fromIndex, +deleteCount, ...newItems?] // newItems = ...[] by default
- *   }
- * }
- */
-export const SPLICE_TAG: "@@SPLICE";
-export class UsageError extends Error {
+export declare function connect<STATE extends State = State, SELECTOR_MAP extends SelectorMap = SelectorMap>(context: ObservableContext<STATE>, selectorMap?: SELECTOR_MAP): <C extends ComponentType<ConnectProps<P, STATE, SELECTOR_MAP>> | NamedExoticComponent<ConnectProps<P, STATE, SELECTOR_MAP>>, P extends InjectedProps<PropsExtract<C, STATE, SELECTOR_MAP>> = InjectedProps<PropsExtract<C, STATE, SELECTOR_MAP>>>(WrappedComponent: C) => ConnectedComponent<P>;
+export declare class UsageError extends Error {
 }
-export type ObservableContext<T extends import("../types").State, SELECTOR_MAP extends BaseSelectorMap<T> = BaseSelectorMap<T>> = IObservableContext<T> | PublicObservableContext<T, SELECTOR_MAP>;
-export type PublicObservableContext<T extends import("../types").State, SELECTOR_MAP extends BaseSelectorMap<T> = BaseSelectorMap<T>> = WithObservableProvider<Context<Store<T, SELECTOR_MAP>>, T>;
-export type IObservableContext<T extends import("../types").State> = WithObservableProvider<Context<IStore>, T>;
-export type WithObservableProvider<T, S extends import("../types").State> = T & {
-    Provider: ObservableProvider<S>;
-};
-export type ObservableProvider<T extends import("../types").State> = ForwardRefExoticComponent<ProviderProps<T>, StoreRef<T>>;
-export type ProviderProps<T extends import("../types").State> = {
-    children?: ReactNode;
-    prehooks?: Prehooks<T>;
-    storage?: IStorage<T>;
-    value: PartialState<T>;
-};
-export type StoreRef<T extends import("../types").State> = {
-    [x: string]: any;
-    getState: () => T;
-} & {
-    resetState: (propertyPaths?: string[]) => void;
-    setState: (changes: import("../types").Changes<T>) => void;
-    subscribe: (listener: import("../types").Listener<T>) => VoidFunction;
-};
-export type State = import("../types").State;
-export type PartialState<T extends import("../types").State> = import("../types").PartialState<T>;
-export type Prehooks<T extends import("../types").State> = import("../types").Prehooks<T>;
-export type BaseSelectorMap<T extends import("../types").State> = import("../types").BaseSelectorMap<T>;
-export type SelectorMap<T extends import("../types").State = import("../types").State, MAP extends BaseSelectorMap<T> = BaseSelectorMap<T>> = import("../types").SelectorMap<T, MAP>;
-export type StoreInternal<T extends import("../types").State> = import("../types").StoreInternal<T>;
-export type PartialStore<T extends import("../types").State, SELECTOR_MAP extends BaseSelectorMap<T> = BaseSelectorMap<T>> = {
-    data?: import("../types").Data<SELECTOR_MAP>;
-    resetState?: (propertyPaths?: string[]) => void;
-    setState?: (changes: import("../types").Changes<T>) => void;
-};
-export type Store<T extends import("../types").State, SELECTOR_MAP extends BaseSelectorMap<T> = BaseSelectorMap<T>> = import("../types").Store<T, SELECTOR_MAP>;
-export type IStore = import("../types").IStore;
-export type IStorage<T extends import("../types").State> = import("../types").IStorage<T>;
-export type ConnectedComponent<OWNPROPS extends Pick<import("../types").State, keyof import("../types").State> & {
-    ref?: unknown;
-} = {}, STORE extends Store<import("../types").State, BaseSelectorMap<import("../types").State>> = Store<import("../types").State, BaseSelectorMap<import("../types").State>>> = MemoExoticComponent<ConnectedComponentProps<OWNPROPS, STORE>>;
-export type ConnectedComponentProps<OWNPROPS extends Pick<import("../types").State, keyof import("../types").State> & {
-    ref?: unknown;
-} = {}, STORE extends Store<import("../types").State, BaseSelectorMap<import("../types").State>> = Store<import("../types").State, BaseSelectorMap<import("../types").State>>> = STORE & OWNPROPS;
-export type OwnProps<P extends import("../types").State = {}> = import("react").PropsWithRef<P>;
-export type NonReactUsageReport = import("../types").NonReactUsageReport;
-export type Data<SELECTOR_MAP extends BaseSelectorMap<import("../types").State> = BaseSelectorMap<import("../types").State>> = import("../types").Data<SELECTOR_MAP>;
-export type ReactNode = import("react").ReactNode;
-export type ForwardRefExoticComponent<P, T> = import('react').ForwardRefExoticComponent<import('react').PropsWithRef<P> & import('react').RefAttributes<T>>;
-export type MemoExoticComponent<P extends {
-    [x: string]: any;
-} = {}> = import('react').MemoExoticComponent<ComponentType<P>>;
-export type ExoticComponent<P extends {
-    [x: string]: any;
-} = {}> = import("react").ExoticComponent<ComponentType<P>>;
-export type ComponentType<P = any> = import("react").ComponentType<P>;
-export type FC<P = {}> = import("react").FC<P>;
-export type Provider<T> = import("react").Provider<T>;
-export type Context<T> = import("react").Context<T>;