add new replaceFromCurrent() method

Author: lostpebble

docs/inject-store-state.md

@@ -23,7 +23,7 @@ function InjectStoreState({ store, on, children }) {
 `SS` = Sub State (which you are selecting to be returned in the child function):
 
 ```tsx
-interface IPropsInjectStoreState<S extends any = any, SS extends any = any> {
+interface IPropsInjectStoreState<S extends object = object, SS extends any = any> {
   store: Store<S>;
   on?: (state: S) => SS;
   children: (output: SS) => React.ReactElement;
@@ -63,4 +63,4 @@ const GreetUser = () => {
     </div>
   )
 }
-```
+```

package.json

@@ -1,6 +1,6 @@
 {
   "name": "pullstate",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "description": "Simple state stores using immer and React hooks",
   "main": "dist/index.js",
   "module": "dist/index.es.js",
@@ -16,7 +16,7 @@
     "test": "jest",
     "test-watch": "jest --watch",
     "clean": "rimraf ./dist",
-    "build": "npm run clean && rollup -c",
+    "build": "npm run clean && rollup -c --bundleConfigAsCjs",
     "uglify": "terser ./dist/index.js -o ./dist/index.js",
     "check-size": "minified-size ./dist/index.es.js",
     "check-size-cjs": "minified-size ./dist/index.js",
@@ -38,40 +38,43 @@
   "license": "MIT",
   "dependencies": {
     "fast-deep-equal": "^3.1.3",
-    "immer": "^9.0.12"
+    "immer": "^9.0.16"
   },
   "repository": "https://github.com/lostpebble/pullstate",
   "devDependencies": {
-    "@testing-library/jest-dom": "^4.1.0",
-    "@testing-library/react": "^9.1.4",
-    "@types/benchmark": "^1.0.31",
-    "@types/jest": "23.3.10",
-    "@types/lodash": "^4.14.121",
-    "@types/react": "16.9.21",
-    "@types/react-dom": "16.9.5",
+    "@testing-library/jest-dom": "^5.16.5",
+    "@testing-library/react": "^13.4.0",
+    "@types/benchmark": "^2.1.2",
+    "@types/jest": "29.2.3",
+    "@types/lodash": "^4.14.190",
+    "@types/react": "18.0.25",
+    "@types/react-dom": "18.0.9",
     "benchmark": "^2.1.4",
-    "cross-env": "^5.2.0",
-    "in-publish": "^2.0.0",
-    "jest": "24.8.0",
+    "cross-env": "^7.0.3",
+    "in-publish": "^2.0.1",
+    "jest": "29.3.1",
     "jest-dom": "^4.0.0",
-    "jest-environment-jsdom": "24.8.0",
-    "jest-environment-jsdom-global": "1.2.0",
-    "js-beautify": "^1.9.0-beta5",
-    "lodash": "^4.17.15",
-    "prettier": "^2.0.5",
-    "react-test-renderer": "^16.8.3",
-    "@rollup/plugin-commonjs": "^11.0.2",
-    "@rollup/plugin-typescript": "^4.1.2",
-    "@rollup/plugin-node-resolve": "^9.0.0",
-    "rollup-plugin-typescript2": "^0.28.0",
+    "jest-environment-jsdom": "29.3.1",
+    "jest-environment-jsdom-global": "4.0.0",
+    "js-beautify": "^1.14.7",
+    "lodash": "^4.17.21",
+    "prettier": "^2.8.0",
+    "react-test-renderer": "^18.2.0",
+    "@rollup/plugin-commonjs": "^23.0.3",
+    "@rollup/plugin-typescript": "^10.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "rollup-plugin-typescript2": "^0.34.1",
     "rollup-plugin-terser": "^7.0.2",
-    "rollup": "^2.32.0",
+    "rollup": "^3.5.0",
     "terser": "^3.16.1",
-    "ts-jest": "^24.0.2",
-    "ts-loader": "^6.0.2",
-    "ts-node": "^8.2.0",
-    "typedoc": "^0.19.2",
-    "typescript": "4.0.3",
+    "ts-jest": "^29.0.3",
+    "ts-loader": "^9.4.1",
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.23.21",
+    "type-fest": "^3.3.0",
+    "typescript": "4.9.3",
     "webpack": "^4.44.2",
     "webpack-cli": "^3.3.12"
   },

rollup.config.js

@@ -2,7 +2,7 @@ import typescript from "rollup-plugin-typescript2";
 import { terser } from "rollup-plugin-terser";
 import { nodeResolve } from "@rollup/plugin-node-resolve";
 import commonjs from "@rollup/plugin-commonjs";
-import pkg from "./package.json";
+import pkg from "./package.json" assert { type: "json" };
 // import typescript from "@rollup/plugin-typescript";
 
 export default [{

src/InjectStoreState.ts

@@ -2,13 +2,13 @@ import React from "react";
 import { Store } from "./Store";
 import { useStoreState } from "./useStoreState";
 
-export interface IPropsInjectStoreState<S extends any = any, SS extends any = any> {
+export interface IPropsInjectStoreState<S extends object = any, SS extends any = any> {
   store: Store<S>;
   on?: (state: S) => SS;
   children: (output: SS) => React.ReactElement;
 }
 
-export function InjectStoreState<S extends any = any, SS = any>({
+export function InjectStoreState<S extends object = any, SS = any>({
   store,
   on = s => s as any,
   children,

src/InjectStoreStateOpt.ts

@@ -1,10 +1,24 @@
 import React from "react";
 import { Store } from "./Store";
 import { useStoreStateOpt } from "./useStoreStateOpt";
+import { ObjectPath } from "./useStoreStateOpt-types";
+import type { GetWithPath } from "type-fest/get";
+
+export interface IPropsInjectStoreStateOpt<
+  T extends readonly unknown[],
+  S extends object = object,
+  P extends ObjectPath<S, T> = T extends ObjectPath<S, T> ? T : never
+> {
+  store: Store<S>;
+  paths: P;
+  children: (output: GetWithPath<S, P>) => React.ReactElement;
+}
+
+/*
 import { DeepTypeOfArray, TAllPathsParameter } from "./useStoreStateOpt-types";
 
 export interface IPropsInjectStoreStateOpt<
-  S extends any = any,
+  S extends object = object,
   P extends TAllPathsParameter<S> = TAllPathsParameter<S>,
   O extends [
     DeepTypeOfArray<S, P[0]>,
@@ -35,25 +49,13 @@ export interface IPropsInjectStoreStateOpt<
   store: Store<S>;
   paths: P;
   children: (output: O) => React.ReactElement;
-}
+}*/
 
 export function InjectStoreStateOpt<
-  S extends any,
-  P extends TAllPathsParameter<S>,
-  O extends [
-    DeepTypeOfArray<S, P[0]>,
-    DeepTypeOfArray<S, P[1]>,
-    DeepTypeOfArray<S, P[2]>,
-    DeepTypeOfArray<S, P[3]>,
-    DeepTypeOfArray<S, P[4]>,
-    DeepTypeOfArray<S, P[5]>,
-    DeepTypeOfArray<S, P[6]>,
-    DeepTypeOfArray<S, P[7]>,
-    DeepTypeOfArray<S, P[8]>,
-    DeepTypeOfArray<S, P[9]>,
-    DeepTypeOfArray<S, P[10]>
-  ]
->({ store, paths, children }: IPropsInjectStoreStateOpt<S, P, O>): React.ReactElement {
-  const state = useStoreStateOpt(store, paths) as O;
+  T extends readonly unknown[],
+  S extends object = object,
+  P extends ObjectPath<S, T> = T extends ObjectPath<S, T> ? T : never
+>({ store, paths, children }: IPropsInjectStoreStateOpt<T, S, P>): React.ReactElement {
+  const state = useStoreStateOpt(store, paths) as GetWithPath<S, P>;
   return children(state);
 }

src/Store.ts

@@ -1,7 +1,6 @@
 // @ts-ignore
 import { applyPatches, Draft, enablePatches, Patch, PatchListener, produce, produceWithPatches } from "immer";
 import { useStoreState } from "./useStoreState";
-import { DeepKeyOfArray } from "./useStoreStateOpt-types";
 
 import isEqual from "fast-deep-equal/es6";
 import { useLocalStore } from "./useLocalStore";
@@ -20,7 +19,7 @@ enablePatches();
 
 export type TPullstateUpdateListener = () => void;
 
-export interface IStoreInternalOptions<S extends any> {
+export interface IStoreInternalOptions<S extends object> {
   ssr: boolean;
   reactionCreators?: TReactionCreator<S>[];
 }
@@ -38,9 +37,9 @@ type TReactionFunction<S extends any, T> = (watched: T, draft: Draft<S>, origina
  */
 type TRunReactionFunction = (forceRun?: boolean) => string[];
 type TRunSubscriptionFunction = () => void;
-type TReactionCreator<S extends any> = (store: Store<S>) => TRunReactionFunction;
+type TReactionCreator<S extends object> = (store: Store<S>) => TRunReactionFunction;
 
-function makeSubscriptionFunction<S extends any, T>(
+function makeSubscriptionFunction<S extends object, T>(
   store: Store<S>,
   watch: (state: S) => T,
   listener: (watched: T, allState: S, previousWatched: T, uid?: string) => void
@@ -58,7 +57,7 @@ function makeSubscriptionFunction<S extends any, T>(
   };
 }
 
-function makeReactionFunctionCreator<S extends any, T>(
+function makeReactionFunctionCreator<S extends object, T>(
   watch: (state: S) => T,
   reaction: TReactionFunction<S, T>
 ): TReactionCreator<S> {
@@ -116,17 +115,17 @@ interface ICreateReactionOptions {
 
 const optPathDivider = "~._.~";
 
-export type TStoreActionUpdate<S extends any> = (
+export type TStoreActionUpdate<S extends object> = (
   updater: TUpdateFunction<S> | TUpdateFunction<S>[],
   patchesCallback?: (patches: Patch[], inversePatches: Patch[]) => void
 ) => void;
 
-export type TStoreAction<S extends any> = (update: TStoreActionUpdate<S>) => void;
+export type TStoreAction<S extends object> = (update: TStoreActionUpdate<S>) => void;
 
 /**
  * @typeParam S  Your store's state interface
  */
-export class Store<S extends any = any> {
+export class Store<S extends object = object> {
   private updateListeners: TPullstateUpdateListener[] = [];
   private currentState: S;
   private readonly initialState: S;
@@ -256,26 +255,6 @@ export class Store<S extends any = any> {
     this.updateListeners.push(listener);
   }
 
-  /**
-   * @internal
-   * @param listener
-   * @param ordKey
-   * @param paths
-   */
-  _addUpdateListenerOpt(listener: TPullstateUpdateListener, ordKey: string, paths: DeepKeyOfArray<S>[]) {
-    this.optimizedUpdateListeners[ordKey] = listener;
-    const listenerPathsKeyed: string[] = paths.map((path) => path.join(optPathDivider));
-    this.optimizedUpdateListenerPaths[ordKey] = listenerPathsKeyed;
-    for (const keyedPath of listenerPathsKeyed) {
-      if (this.optimizedListenerPropertyMap[keyedPath] == null) {
-        this.optimizedListenerPropertyMap[keyedPath] = [ordKey];
-      } else {
-        this.optimizedListenerPropertyMap[keyedPath].push(ordKey);
-      }
-    }
-    this._optListenerCount++;
-  }
-
   /**
    * @internal
    * @param listener
@@ -462,12 +441,16 @@ export class Store<S extends any = any> {
     this._updateState(newState);
   }
 
+  replaceFromCurrent(replacer: (state: S) => S) {
+    this._updateState(replacer(this.currentState));
+  }
+
   applyPatches(patches: Patch[]) {
     applyPatchesToStore(this, patches);
   }
 }
 
-export function applyPatchesToStore<S extends any = any>(store: Store<S>, patches: Patch[]) {
+export function applyPatchesToStore<S extends object = object>(store: Store<S>, patches: Patch[]) {
   const currentState: S = store.getRawState();
   const nextState = applyPatches(currentState as any, patches);
   if (nextState !== currentState) {
@@ -521,14 +504,14 @@ function runUpdates<S extends any>(
   return func
     ? (produceWithPatches(currentState, (s: S) => (updater as TUpdateFunction<S>)(s as Draft<S>, currentState)) as any)
     : ((updater as TUpdateFunction<S>[]).reduce(
-      ([nextState, patches, inversePatches], currentValue) => {
-        const resp = produceWithPatches(nextState as any, (s: S) => currentValue(s as Draft<S>, nextState)) as any;
-        patches.push(...resp[1]);
-        inversePatches.push(...resp[2]);
-        return [resp[0], patches, inversePatches];
-      },
-      [currentState, [], []] as [S, Patch[], Patch[]]
-    ) as [S, Patch[], Patch[]]);
+        ([nextState, patches, inversePatches], currentValue) => {
+          const resp = produceWithPatches(nextState as any, (s: S) => currentValue(s as Draft<S>, nextState)) as any;
+          patches.push(...resp[1]);
+          inversePatches.push(...resp[2]);
+          return [resp[0], patches, inversePatches];
+        },
+        [currentState, [], []] as [S, Patch[], Patch[]]
+      ) as [S, Patch[], Patch[]]);
 }
 
 /**
@@ -537,7 +520,7 @@ function runUpdates<S extends any>(
  * @param updater  The update function, or an array of update functions
  * @param patchesCallback  A callback to keep track of the patches made during this update.
  */
-export function update<S extends any = any>(
+export function update<S extends object = object>(
   store: Store<S>,
   updater: TUpdateFunction<S> | TUpdateFunction<S>[],
   patchesCallback?: (patches: Patch[], inversePatches: Patch[]) => void
@@ -577,8 +560,8 @@ export function update<S extends any = any>(
         func
           ? (updater as TUpdateFunction<S>)(s as Draft<S>, currentState)
           : (updater as TUpdateFunction<S>[]).reduce((previousValue, currentUpdater) => {
-            return produce(previousValue as any, (s: S) => currentUpdater(s as Draft<S>, previousValue)) as any;
-          }, currentState)
+              return produce(previousValue as any, (s: S) => currentUpdater(s as Draft<S>, previousValue)) as any;
+            }, currentState)
       ) as any;
     }
 

src/async.ts

@@ -665,7 +665,7 @@ further looping. Fix in your cacheBreakHook() is needed.`);
 
     const watchOrd = watchIdOrd++;
 
-    throw new Promise((resolve) => {
+    throw new Promise<void>((resolve) => {
       cache.listeners[key][watchOrd] = () => {
         delete cache.listeners[key][watchOrd];
         resolve();

src/globalClientState.ts

@@ -4,7 +4,7 @@ export const globalClientState: {
   storeOrdinal: number,
   batching: boolean;
   flushStores: {
-    [storeName: number]: Store;
+    [storeName: number]: Store<any>;
   };
 } = {
   storeOrdinal: 0,

src/index.ts

@@ -1,5 +1,4 @@
 import { useStoreState } from "./useStoreState";
-import { useStoreStateOpt } from "./useStoreStateOpt";
 import { Store, TStoreAction, TUpdateFunction, update } from "./Store";
 import { InjectStoreState } from "./InjectStoreState";
 import type { PullstateSingleton } from "./PullstateCore";
@@ -15,7 +14,6 @@ import {
 } from "./PullstateCore";
 import { createAsyncAction, createAsyncActionDirect, errorResult, successResult } from "./async";
 import { EAsyncActionInjectType, InjectAsyncAction, TInjectAsyncActionProps } from "./InjectAsyncAction";
-import { InjectStoreStateOpt } from "./InjectStoreStateOpt";
 import { TUseResponse } from "./async-types";
 import { registerInDevtools } from "./reduxDevtools";
 import { useLocalStore } from "./useLocalStore";
@@ -25,12 +23,10 @@ export * from "./async-types";
 
 export {
   useStoreState,
-  useStoreStateOpt,
   useLocalStore,
   update,
   Store,
   InjectStoreState,
-  InjectStoreStateOpt,
   PullstateProvider,
   useStores,
   useInstance,

src/useLocalStore.ts

@@ -2,7 +2,7 @@ import { Store } from "./Store";
 import { useRef } from "react";
 import isEqual from "fast-deep-equal/es6";
 
-function useLocalStore<S extends any>(initialState: (() => S) | S, deps?: ReadonlyArray<any>): Store<S> {
+function useLocalStore<S extends object>(initialState: (() => S) | S, deps?: ReadonlyArray<any>): Store<S> {
   const storeRef = useRef<Store<S>>();
 
   if (storeRef.current == null) {

src/useStoreState.ts

@@ -21,8 +21,8 @@ export interface IUpdateRefNew {
 
 const onServer = typeof window === "undefined";
 
-function useStoreState<S extends any = any>(store: Store<S>): S;
-function useStoreState<S extends any = any, SS = any>(
+function useStoreState<S extends object = any>(store: Store<S>): S;
+function useStoreState<S extends object = any, SS = any>(
   store: Store<S>,
   getSubState: (state: S) => SS,
   deps?: ReadonlyArray<any>