react-redux-cache 0.21.0 → 0.22.0

package/dist/esm/utilsAndConstants.js

@@ -45,7 +45,7 @@ export const defaultGetCacheKey = (params) => {
 }
 
 export const applyEntityChanges = (entities, changes, options) => {
-  var _a, _b, _c, _d
+  var _a, _b, _c
   if (changes.merge && changes.entities) {
     logWarn('applyEntityChanges', 'merge and entities should not be both set')
   }
@@ -53,6 +53,7 @@ export const applyEntityChanges = (entities, changes, options) => {
   if (!merge && !replace && !remove) {
     return undefined
   }
+  const mutable = options.mutableCollections
   const deepEqual = options.deepComparisonEnabled ? optionalUtils.deepEqual : undefined
   let result
   const objectWithAllTypenames = Object.assign(
@@ -95,37 +96,48 @@ export const applyEntityChanges = (entities, changes, options) => {
         logWarn('applyEntityChanges', 'merge, replace and remove changes have intersections for: ' + typename)
       }
     }
-    const oldEntities = (_d = entities[typename]) !== null && _d !== void 0 ? _d : EMPTY_OBJECT
+    const oldEntities = entities[typename]
     let newEntities
     entitiesToRemove === null || entitiesToRemove === void 0
       ? void 0
       : entitiesToRemove.forEach((id) => {
-          if (oldEntities[id]) {
+          if (oldEntities === null || oldEntities === void 0 ? void 0 : oldEntities[id]) {
             newEntities !== null && newEntities !== void 0
               ? newEntities
-              : (newEntities = Object.assign({}, oldEntities))
+              : (newEntities = mutable ? oldEntities : Object.assign({}, oldEntities))
             delete newEntities[id]
           }
         })
     if (entitiesToReplace) {
       for (const id in entitiesToReplace) {
         const newEntity = entitiesToReplace[id]
-        if (!(deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldEntities[id], newEntity))) {
+        if (
+          oldEntities === undefined ||
+          !(deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldEntities[id], newEntity))
+        ) {
           newEntities !== null && newEntities !== void 0
             ? newEntities
-            : (newEntities = Object.assign({}, oldEntities))
+            : (newEntities = mutable
+                ? oldEntities !== null && oldEntities !== void 0
+                  ? oldEntities
+                  : {}
+                : Object.assign({}, oldEntities))
           newEntities[id] = newEntity
         }
       }
     }
     if (entitiesToMerge) {
       for (const id in entitiesToMerge) {
-        const oldEntity = oldEntities[id]
+        const oldEntity = oldEntities === null || oldEntities === void 0 ? void 0 : oldEntities[id]
         const newEntity = Object.assign(Object.assign({}, oldEntity), entitiesToMerge[id])
         if (!(deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldEntity, newEntity))) {
           newEntities !== null && newEntities !== void 0
             ? newEntities
-            : (newEntities = Object.assign({}, oldEntities))
+            : (newEntities = mutable
+                ? oldEntities !== null && oldEntities !== void 0
+                  ? oldEntities
+                  : {}
+                : Object.assign({}, oldEntities))
           newEntities[id] = newEntity
         }
       }
@@ -133,7 +145,15 @@ export const applyEntityChanges = (entities, changes, options) => {
     if (!newEntities) {
       continue
     }
-    result !== null && result !== void 0 ? result : (result = Object.assign({}, entities))
+    if (mutable) {
+      incrementChangeKey(newEntities)
+      if (result === undefined) {
+        incrementChangeKey(entities)
+        result = entities
+      }
+    } else {
+      result !== null && result !== void 0 ? result : (result = Object.assign({}, entities))
+    }
     result[typename] = newEntities
   }
   options.logsEnabled &&
@@ -146,8 +166,8 @@ export const applyEntityChanges = (entities, changes, options) => {
   return result
 }
 
-export const isEmptyObject = (o) => {
-  for (const _ in o) {
+export const isEmptyObject = (obj) => {
+  for (const _ in obj) {
     return false
   }
   return true
@@ -177,3 +197,11 @@ export const FetchPolicy = {
   },
   Always: () => true,
 }
+
+export const incrementChangeKey = (mutable) => {
+  if (mutable._changeKey === undefined) {
+    mutable._changeKey = 0
+  } else {
+    mutable._changeKey += 1
+  }
+}

package/dist/types/createCache.d.ts

@@ -2,7 +2,6 @@ import type {
   Cache,
   CacheOptions,
   CacheState,
-  Dict,
   EntitiesMap,
   EntityChanges,
   Globals,
@@ -127,7 +126,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
         }
         type: `@rrc/${N}/mergeEntityChanges`
       }
-      /** Invalidates query states. */
+      /** Sets expiresAt to Date.now(). */
       invalidateQuery: {
         <K extends keyof QP & keyof QR>(
           queries: {
@@ -255,9 +254,12 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
         typename: TN
       ) => T[TN] | undefined
       /** Selects all entities. */
-      selectEntities: (state: unknown) => EntitiesMap<T>
+      selectEntities: (state: unknown) => EntitiesMap<T> & import('./types').Mutable
       /** Selects all entities of provided typename. */
-      selectEntitiesByTypename: <TN extends keyof T>(state: unknown, typename: TN) => EntitiesMap<T>[TN]
+      selectEntitiesByTypename: <TN extends keyof T>(
+        state: unknown,
+        typename: TN
+      ) => (EntitiesMap<T> & import('./types').Mutable)[TN]
     }
     hooks: {
       /** Returns memoized object with query and mutate functions. Memoization dependency is the store. */
@@ -331,6 +333,13 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
       ]
       /** useSelector + selectEntityById. */
       useSelectEntityById: <TN extends keyof T>(id: Key | null | undefined, typename: TN) => T[TN] | undefined
+      /**
+       * useSelector + selectEntitiesByTypename. Also subscribes to collection's change key if `mutableCollections` enabled.
+       * @warning Subscribing to collections should be avoided.
+       * */
+      useEntitiesByTypename: <TN extends keyof T>(
+        typename: TN
+      ) => (EntitiesMap<T> & import('./types').Mutable)[TN]
     }
     utils: {
       /** Creates client by providing the store. Can be used when the store is a singleton - to not use a useClient hook for getting the client, but import it directly. */
@@ -481,7 +490,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
       }
       type: `@rrc/${N}/mergeEntityChanges`
     }
-    /** Invalidates query states. */
+    /** Sets expiresAt to Date.now(). */
     invalidateQuery: {
       <K extends keyof QP & keyof QR>(
         queries: {
@@ -616,9 +625,12 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
       typename: TN
     ) => object | undefined
     /** Selects all entities. */
-    selectEntities: (state: unknown) => EntitiesMap<Typenames>
+    selectEntities: (state: unknown) => EntitiesMap<Typenames> & import('./types').Mutable
     /** Selects all entities of provided typename. */
-    selectEntitiesByTypename: <TN extends string>(state: unknown, typename: TN) => Dict<object> | undefined
+    selectEntitiesByTypename: <TN extends string>(
+      state: unknown,
+      typename: TN
+    ) => (EntitiesMap<Typenames> & import('./types').Mutable)[TN]
   }
   hooks: {
     /** Returns memoized object with query and mutate functions. Memoization dependency is the store. */
@@ -692,6 +704,13 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
     ]
     /** useSelector + selectEntityById. */
     useSelectEntityById: <TN extends string>(id: Key | null | undefined, typename: TN) => object | undefined
+    /**
+     * useSelector + selectEntitiesByTypename. Also subscribes to collection's change key if `mutableCollections` enabled.
+     * @warning Subscribing to collections should be avoided.
+     * */
+    useEntitiesByTypename: <TN extends string>(
+      typename: TN
+    ) => (EntitiesMap<Typenames> & import('./types').Mutable)[TN]
   }
   utils: {
     /** Creates client by providing the store. Can be used when the store is a singleton - to not use a useClient hook for getting the client, but import it directly. */
@@ -720,7 +739,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
      * Performs additional checks for intersections if `additionalValidation` option is `true`, and prints warnings if finds any issues.
      */
     applyEntityChanges: (
-      entities: EntitiesMap<Typenames>,
+      entities: EntitiesMap<Typenames> & import('./types').Mutable,
       changes: EntityChanges<Typenames>
     ) => EntitiesMap<Typenames> | undefined
   }

package/dist/types/createSelectors.d.ts

@@ -12,6 +12,11 @@ export type Selectors<
 export declare const createSelectors: <N extends string, T extends Typenames, QP, QR, MP, MR>(
   cache: Cache<N, T, QP, QR, MP, MR>
 ) => {
+  selectEntityById: <TN extends keyof T>(
+    state: unknown,
+    id: Key | null | undefined,
+    typename: TN
+  ) => T[TN] | undefined
   selectQueryState: <QK extends keyof (QP & QR)>(
     state: unknown,
     query: QK,
@@ -67,14 +72,9 @@ export declare const createSelectors: <N extends string, T extends Typenames, QP
     state: unknown,
     mutation: MK
   ) => (MK extends keyof MP & keyof MR ? MP[MK] : never) | undefined
-  selectEntityById: <TN extends keyof T>(
-    state: unknown,
-    id: Key | null | undefined,
-    typename: TN
-  ) => T[TN] | undefined
-  selectEntities: (state: unknown) => import('./types').EntitiesMap<T>
+  selectEntities: (state: unknown) => import('./types').EntitiesMap<T> & import('./types').Mutable
   selectEntitiesByTypename: <TN extends keyof T>(
     state: unknown,
     typename: TN
-  ) => import('./types').EntitiesMap<T>[TN]
+  ) => (import('./types').EntitiesMap<T> & import('./types').Mutable)[TN]
 }

package/dist/types/types.d.ts

@@ -3,7 +3,15 @@ import type {Selectors} from './createSelectors'
 
 export type Key = string | number | symbol
 
-export type Dict<T> = Record<Key, T>
+export type Mutable = {
+  /**
+   * Used only when mutable cache enabled. Always incremented when collection changed by reducer to allow subscribe on changes.
+   * Should not be used for comparing different collections as supposed to be compared only with previously saved changeKey of the same collection.
+   */
+  _changeKey?: number
+}
+
+export type Dict<T> = Record<Key, T> & Mutable
 
 export type OptionalPartial<T, K extends keyof T> = Partial<{
   [A in K]: Partial<T[A]>
@@ -95,6 +103,13 @@ export type Globals<N extends string, T extends Typenames, QP, QR, MP, MR> = {
 }
 
 export type CacheOptions = {
+  /**
+   * BETA: Optimization that makes state collections mutable.
+   * Subscription to mutable collecitons will work only when subscribed to both collection and its change key - collections
+   * still can be replaced with the new ones instead of mutating e.g. when clearing state.
+   * @Default false
+   * */
+  mutableCollections: boolean
   /** Enables additional validation with logging to console.warn. Recommended to enable in dev/testing mode. @Default true in dev mode. */
   additionalValidation: boolean
   /** Enables debug logs. @Default false */
@@ -121,13 +136,13 @@ export type EntityIds<T extends Typenames> = {
 }
 
 export type CacheState<T extends Typenames, QP, QR, MP, MR> = {
-  entities: EntitiesMap<T>
+  entities: EntitiesMap<T> & Mutable
   queries: {
     [QK in keyof (QP | QR)]: Dict<QueryState<T, QP[QK], QR[QK]> | undefined>
-  }
+  } & Mutable
   mutations: {
     [MK in keyof (MP | MR)]: MutationState<T, MP[MK], MR[MK]>
-  }
+  } & Mutable
 }
 
 export type QueryInfo<

package/dist/types/utilsAndConstants.d.ts

@@ -3,6 +3,7 @@ import type {
   EntitiesMap,
   EntityChanges,
   Key,
+  Mutable,
   QueryState,
   QueryStateComparer,
   Typenames,
@@ -31,13 +32,13 @@ export declare const noop: () => void
 export declare const defaultGetCacheKey: <P = unknown>(params: P) => Key
 
 export declare const applyEntityChanges: <T extends Typenames>(
-  entities: EntitiesMap<T>,
+  entities: EntitiesMap<T> & Mutable,
   changes: EntityChanges<T>,
   options: CacheOptions
 ) => EntitiesMap<T> | undefined
 
 /** Returns true if object has no keys. */
-export declare const isEmptyObject: (o: object) => boolean
+export declare const isEmptyObject: (obj: object) => boolean
 
 /** Returns query state comparer that compares only provided fields. Used in implementation of `selectorComparer` option. */
 export declare const createStateComparer: <T extends Typenames = Typenames, Q = unknown, P = unknown>(
@@ -57,3 +58,5 @@ export declare const FetchPolicy: {
   /** Every fetch trigger. */
   Always: () => boolean
 }
+
+export declare const incrementChangeKey: (mutable: Mutable) => void

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Powerful data fetching and caching library for Redux and Zustand that supports normalization.",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -17,8 +17,8 @@
   "scripts": {
     "example": "(cd example && yarn --production && yarn dev)",
     "clean": "rm -rf dist",
-    "lint": "yarn eslint",
-    "lint-fix": "yarn eslint --fix",
+    "lint": "yarn eslint ./src",
+    "lint-fix": "yarn eslint --fix ./src",
     "lint-fix-dist": "yarn eslint --quiet --fix dist/ > /dev/null 2>&1 || true",
     "build-cjs": "tsc -p tsconfig.cjs.json && rm -rf dist/cjs/testing && rm -rf dist/cjs/__tests__",
     "build-esm": "tsc -p tsconfig.esm.json > /dev/null ; rm -rf dist/esm/testing && rm -rf dist/esm/__tests__",
@@ -31,7 +31,8 @@
     "publish-rc": "npm publish --tag rc",
     "remove-rc": "npm version <same-version-without-rc>",
     "prepublishOnly": "yarn build && yarn test",
-    "generate-docs": "node --experimental-strip-types scripts/generate-docs.ts"
+    "generate-docs": "node --experimental-strip-types scripts/generate-docs.ts",
+    "benchmark": "NODE_ENV=production node -r ts-node/register --expose-gc benchmark.ts"
   },
   "peerDependencies": {
     "fast-deep-equal": "*",
@@ -72,6 +73,7 @@
     "redux": "4.2.1",
     "redux-logger": "3.0.6",
     "ts-jest": "29.1.0",
+    "ts-node": "10.9.2",
     "typescript": "5.6.3"
   },
   "files": [