use-mutative
Version:
A hook to use Mutative as a React hook to efficient update react state immutable with mutable way
178 lines • 22.9 kB
JavaScript
import { create, } from 'mutative';
import { useState, useReducer, useCallback, useMemo, useRef, useEffect, } from 'react';
/**
* `useMutative` is a hook that is similar to `useState` but it uses `mutative` to handle the state updates.
*
* @example
*
* ```ts
* import { act, renderHook } from '@testing-library/react';
*
* import { useMutative } from '../src/index';
*
* const { result } = renderHook(() => useMutative({ items: [1] }));
* const [state, updateState] = result.current;
* act(() =>
* updateState((draft) => {
* draft.items.push(2);
* })
* );
* const [nextState] = result.current;
* expect(nextState).toEqual({ items: [1, 2] });
* ```
*/
function useMutative(
/**
* The initial state. You may optionally provide an initializer function to calculate the initial state.
*/
initialValue,
/**
* Options for the `useMutative` hook.
*/
options) {
const patchesRef = useRef({
patches: [],
inversePatches: [],
});
//#region support strict mode and concurrent features
const count = useRef(0);
const renderCount = useRef(0);
let currentCount = count.current;
useEffect(() => {
count.current = currentCount;
renderCount.current = currentCount;
});
currentCount += 1;
renderCount.current += 1;
//#endregion
const [state, setState] = useState(() => typeof initialValue === 'function' ? initialValue() : initialValue);
const updateState = useCallback((updater) => {
setState((latest) => {
const updaterFn = typeof updater === 'function' ? updater : () => updater;
const result = create(latest, updaterFn, options);
if (options === null || options === void 0 ? void 0 : options.enablePatches) {
// check render count, support strict mode and concurrent features
if (renderCount.current === count.current ||
renderCount.current === count.current + 1) {
Array.prototype.push.apply(patchesRef.current.patches, result[1]);
// `inversePatches` should be in reverse order when multiple setState() executions
Array.prototype.unshift.apply(patchesRef.current.inversePatches, result[2]);
}
return result[0];
}
return result;
});
}, []);
useEffect(() => {
if (options === null || options === void 0 ? void 0 : options.enablePatches) {
// Reset `patchesRef` when the component is rendered each time
patchesRef.current.patches = [];
patchesRef.current.inversePatches = [];
}
});
return ((options === null || options === void 0 ? void 0 : options.enablePatches)
? [
state,
updateState,
patchesRef.current.patches,
patchesRef.current.inversePatches,
]
: [state, updateState]);
}
/**
* `useMutativeReducer` is a hook that is similar to `useReducer` but it uses `mutative` to handle the state updates.
*
* @example
*
* ```ts
* import { act, renderHook } from '@testing-library/react';
* import { type Draft } from 'mutative';
*
* import { useMutativeReducer } from '../src/index';
*
* const { result } = renderHook(() =>
* useMutativeReducer(
* (
* draft: Draft<Readonly<{ count: number }>>,
* action: {
* type: 'increment';
* }
* ) => {
* switch (action.type) {
* case 'increment':
* draft.count += 1;
* }
* },
* { count: 0 }
* )
* );
* const [, dispatch] = result.current;
* act(() => dispatch({ type: 'increment' }));
* expect(result.current[0]).toEqual({ count: 1 });
* ```
*/
function useMutativeReducer(
/**
* A function that returns the next state tree, given the current state tree and the action to handle.
*/
reducer,
/**
* The initial state. You may optionally provide an initializer function to calculate the initial state.
*/
initializerArg,
/**
* An initializer function that returns the initial state. It will be called with `initializerArg`.
*/
initializer,
/**
* Options for the `useMutativeReducer` hook.
*/
options) {
const patchesRef = useRef({
patches: [],
inversePatches: [],
});
//#region support strict mode and concurrent features
const count = useRef(0);
const renderCount = useRef(0);
let currentCount = count.current;
useEffect(() => {
count.current = currentCount;
renderCount.current = currentCount;
});
currentCount += 1;
renderCount.current += 1;
//#endregion
const cachedReducer = useMemo(() => (state, action) => {
const result = create(state, (draft) => reducer(draft, action), options);
if (options === null || options === void 0 ? void 0 : options.enablePatches) {
// check render count, support strict mode and concurrent features
if (renderCount.current === count.current ||
renderCount.current === count.current + 1) {
Array.prototype.push.apply(patchesRef.current.patches, result[1]);
// `inversePatches` should be in reverse order when multiple setState() executions
Array.prototype.unshift.apply(patchesRef.current.inversePatches, result[2]);
}
return result[0];
}
return result;
}, [reducer]);
const result = useReducer(cachedReducer, initializerArg, initializer);
useEffect(() => {
if (options === null || options === void 0 ? void 0 : options.enablePatches) {
// Reset `patchesRef` when the component is rendered each time
patchesRef.current.patches = [];
patchesRef.current.inversePatches = [];
}
});
return (options === null || options === void 0 ? void 0 : options.enablePatches)
? [
result[0],
result[1],
patchesRef.current.patches,
patchesRef.current.inversePatches,
]
: result;
}
export { useMutative, useMutativeReducer, };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  create,\n  type Immutable,\n  type Patches,\n  type Options,\n  type Draft,\n} from 'mutative';\nimport {\n  useState,\n  useReducer,\n  useCallback,\n  useMemo,\n  useRef,\n  Dispatch,\n  useEffect,\n} from 'react';\n\ntype PatchesOptions =\n  | boolean\n  | {\n      /**\n       * The default value is `true`. If it's `true`, the path will be an array, otherwise it is a string.\n       */\n      pathAsArray?: boolean;\n      /**\n       * The default value is `true`. If it's `true`, the array length will be included in the patches, otherwise no include array length.\n       */\n      arrayLengthAssignment?: boolean;\n    };\n\ntype DraftFunction<S> = (draft: Draft<S>) => void;\ntype Updater<S> = (value: S | (() => S) | DraftFunction<S>) => void;\n\ntype InitialValue<I extends any> = I extends (...args: any) => infer R ? R : I;\n\ntype Result<S, O extends PatchesOptions, F extends boolean> = O extends\n  | true\n  | object\n  ? [F extends true ? Immutable<S> : S, Updater<S>, Patches<O>, Patches<O>]\n  : F extends true\n    ? [Immutable<S>, Updater<S>]\n    : [S, Updater<S>];\n\n/**\n * `useMutative` is a hook that is similar to `useState` but it uses `mutative` to handle the state updates.\n *\n *  @example\n *\n * ```ts\n * import { act, renderHook } from '@testing-library/react';\n *\n * import { useMutative } from '../src/index';\n *\n * const { result } = renderHook(() => useMutative({ items: [1] }));\n * const [state, updateState] = result.current;\n * act(() =>\n *   updateState((draft) => {\n *     draft.items.push(2);\n *   })\n * );\n * const [nextState] = result.current;\n * expect(nextState).toEqual({ items: [1, 2] });\n * ```\n */\nfunction useMutative<\n  S,\n  F extends boolean = false,\n  O extends PatchesOptions = false,\n>(\n  /**\n   * The initial state. You may optionally provide an initializer function to calculate the initial state.\n   */\n  initialValue: S,\n  /**\n   * Options for the `useMutative` hook.\n   */\n  options?: Options<O, F>\n) {\n  const patchesRef = useRef<{\n    patches: Patches;\n    inversePatches: Patches;\n  }>({\n    patches: [],\n    inversePatches: [],\n  });\n  //#region support strict mode and concurrent features\n  const count = useRef(0);\n  const renderCount = useRef(0);\n  let currentCount = count.current;\n  useEffect(() => {\n    count.current = currentCount;\n    renderCount.current = currentCount;\n  });\n  currentCount += 1;\n  renderCount.current += 1;\n  //#endregion\n  const [state, setState] = useState(() =>\n    typeof initialValue === 'function' ? initialValue() : initialValue\n  );\n  const updateState = useCallback((updater: any) => {\n    setState((latest: any) => {\n      const updaterFn = typeof updater === 'function' ? updater : () => updater;\n      const result = create(latest, updaterFn, options);\n      if (options?.enablePatches) {\n        // check render count, support strict mode and concurrent features\n        if (\n          renderCount.current === count.current ||\n          renderCount.current === count.current + 1\n        ) {\n          Array.prototype.push.apply(patchesRef.current.patches, result[1]);\n          // `inversePatches` should be in reverse order when multiple setState() executions\n          Array.prototype.unshift.apply(\n            patchesRef.current.inversePatches,\n            result[2]\n          );\n        }\n        return result[0];\n      }\n      return result;\n    });\n  }, []);\n  useEffect(() => {\n    if (options?.enablePatches) {\n      // Reset `patchesRef` when the component is rendered each time\n      patchesRef.current.patches = [];\n      patchesRef.current.inversePatches = [];\n    }\n  });\n  return (\n    options?.enablePatches\n      ? [\n          state,\n          updateState,\n          patchesRef.current.patches,\n          patchesRef.current.inversePatches,\n        ]\n      : [state, updateState]\n  ) as Result<InitialValue<S>, O, F>;\n}\n\ntype ReducerResult<\n  S,\n  A,\n  O extends PatchesOptions,\n  F extends boolean,\n> = O extends true | object\n  ? [F extends true ? Immutable<S> : S, Dispatch<A>, Patches<O>, Patches<O>]\n  : F extends true\n    ? [Immutable<S>, Dispatch<A>]\n    : [S, Dispatch<A>];\n\ntype Reducer<S, A> = (draftState: Draft<S>, action: A) => void | S | undefined;\n\nfunction useMutativeReducer<\n  S,\n  A,\n  I,\n  F extends boolean = false,\n  O extends PatchesOptions = false,\n>(\n  reducer: Reducer<S, A>,\n  initializerArg: S & I,\n  initializer: (arg: S & I) => S,\n  options?: Options<O, F>\n): ReducerResult<S, A, O, F>;\n\nfunction useMutativeReducer<\n  S,\n  A,\n  I,\n  F extends boolean = false,\n  O extends PatchesOptions = false,\n>(\n  reducer: Reducer<S, A>,\n  initializerArg: I,\n  initializer: (arg: I) => S,\n  options?: Options<O, F>\n): ReducerResult<S, A, O, F>;\n\nfunction useMutativeReducer<\n  S,\n  A,\n  F extends boolean = false,\n  O extends PatchesOptions = false,\n>(\n  reducer: Reducer<S, A>,\n  initialState: S,\n  initializer?: undefined,\n  options?: Options<O, F>\n): ReducerResult<S, A, O, F>;\n\n/**\n * `useMutativeReducer` is a hook that is similar to `useReducer` but it uses `mutative` to handle the state updates.\n *\n * @example\n *\n * ```ts\n * import { act, renderHook } from '@testing-library/react';\n * import { type Draft } from 'mutative';\n *\n * import { useMutativeReducer } from '../src/index';\n *\n * const { result } = renderHook(() =>\n *   useMutativeReducer(\n *     (\n *       draft: Draft<Readonly<{ count: number }>>,\n *       action: {\n *         type: 'increment';\n *       }\n *     ) => {\n *       switch (action.type) {\n *         case 'increment':\n *           draft.count += 1;\n *       }\n *     },\n *     { count: 0 }\n *   )\n * );\n * const [, dispatch] = result.current;\n * act(() => dispatch({ type: 'increment' }));\n * expect(result.current[0]).toEqual({ count: 1 });\n * ```\n */\nfunction useMutativeReducer<\n  S,\n  A,\n  I,\n  F extends boolean = false,\n  O extends PatchesOptions = false,\n>(\n  /**\n   * A function that returns the next state tree, given the current state tree and the action to handle.\n   */\n  reducer: Reducer<S, A>,\n  /**\n   * The initial state. You may optionally provide an initializer function to calculate the initial state.\n   */\n  initializerArg: S & I,\n  /**\n   * An initializer function that returns the initial state. It will be called with `initializerArg`.\n   */\n  initializer?: (arg: S & I) => S,\n  /**\n   * Options for the `useMutativeReducer` hook.\n   */\n  options?: Options<O, F>\n): ReducerResult<S, A, O, F> {\n  const patchesRef = useRef<{\n    patches: Patches;\n    inversePatches: Patches;\n  }>({\n    patches: [],\n    inversePatches: [],\n  });\n  //#region support strict mode and concurrent features\n  const count = useRef(0);\n  const renderCount = useRef(0);\n  let currentCount = count.current;\n  useEffect(() => {\n    count.current = currentCount;\n    renderCount.current = currentCount;\n  });\n  currentCount += 1;\n  renderCount.current += 1;\n  //#endregion\n  const cachedReducer: any = useMemo(\n    () => (state: any, action: any) => {\n      const result: any = create(\n        state,\n        (draft) => reducer(draft, action),\n        options\n      );\n      if (options?.enablePatches) {\n        // check render count, support strict mode and concurrent features\n        if (\n          renderCount.current === count.current ||\n          renderCount.current === count.current + 1\n        ) {\n          Array.prototype.push.apply(patchesRef.current.patches, result[1]);\n          // `inversePatches` should be in reverse order when multiple setState() executions\n          Array.prototype.unshift.apply(\n            patchesRef.current.inversePatches,\n            result[2]\n          );\n        }\n        return result[0];\n      }\n      return result;\n    },\n    [reducer]\n  );\n  const result: any = useReducer(\n    cachedReducer,\n    initializerArg as any,\n    initializer as any\n  );\n  useEffect(() => {\n    if (options?.enablePatches) {\n      // Reset `patchesRef` when the component is rendered each time\n      patchesRef.current.patches = [];\n      patchesRef.current.inversePatches = [];\n    }\n  });\n  return options?.enablePatches\n    ? [\n        result[0],\n        result[1],\n        patchesRef.current.patches,\n        patchesRef.current.inversePatches,\n      ] as ReducerResult<S, A, O, F>\n    : result;\n}\n\nexport {\n  type DraftFunction,\n  type Updater,\n  type Reducer,\n  useMutative,\n  useMutativeReducer,\n};\n"]}