@inglorious/store 12.0.0 → 12.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inglorious/store",
-  "version": "12.0.0",
+  "version": "12.1.0",
   "description": "A state manager for real-time, collaborative apps, inspired by game development patterns and compatible with Redux.",
   "author": "Matteo Antony Mistretta <antony.mistretta@gmail.com> (https://ingloriouscoderz.it)",
   "license": "MIT",
@@ -82,7 +82,7 @@
     "@inglorious/utils": "5.1.0"
   },
   "devDependencies": {
-    "@inglorious/eslint-config": "1.1.4",
+    "@inglorious/eslint-config": "1.2.0",
     "@reduxjs/toolkit": "^2.12.0",
     "prettier": "^3.9.6",
     "typescript": "~7.0.2",

package/src/client/devtools.js

@@ -33,13 +33,17 @@ export function createDevtools(config = {}) {
 
     middleware(store) {
       connectDevTools(store, config)
-      return (next) => (event) => {
+
+      const next = store.dispatch
+      store.dispatch = (event) => {
         const result = next(event)
         if (shouldLogEvent(event, config)) {
           sendAction(event, store.getState())
         }
         return result
       }
+
+      return store
     },
   }
 }

package/src/client/multiplayer-middleware.js

@@ -19,7 +19,17 @@ export function multiplayerMiddleware(config = {}) {
   const localQueue = []
 
   // The middleware function that will be applied to the store.
-  return (store) => (next) => (event) => {
+  return (store) => {
+    const next = store.dispatch
+    store.dispatch = (event) => send(store, event, next)
+    return store
+  }
+
+  /**
+   * Sends an event to the server unless it is filtered out or came from there, then
+   * passes it on to the next middleware, and eventually to the store.
+   */
+  function send(store, event, next) {
     const shouldBeSent =
       (!blacklist.length || !blacklist.includes(event.type)) &&
       (!whitelist.length || whitelist.includes(event.type)) &&

package/src/middlewares.js

@@ -1,37 +1,16 @@
-import { compose } from "@inglorious/utils/functions"
-
 /**
- * Applies a list of middleware functions to a store's dispatch method.
- * @param {...Function} middlewares The middleware functions to apply.
- * @returns {Function} A store enhancer function.
+ * Wraps the store with each middleware. A middleware takes the store and returns it,
+ * changed or wrapped: one that only looks at events replaces `dispatch` with a function
+ * that calls the previous one, and returns its result. The first middleware wraps all
+ * the others, so events pass through them in the order they are listed.
+ *
+ * @param {Object} store - The store to wrap.
+ * @param {Function[]} middlewares - The middlewares, each taking the store and returning it.
+ * @returns {Object} The wrapped store.
  */
-export function applyMiddlewares(...middlewares) {
-  return (store) => {
-    let dispatch = () => {
-      throw new Error(
-        "Dispatching while constructing your middleware is not allowed.",
-      )
-    }
-
-    // Enhanced store interface that middlewares receive
-    const middlewareStore = {
-      ...store,
-      dispatch: (...args) => dispatch(...args),
-      notify: (type, payload) => dispatch({ type, payload }),
-    }
-
-    // Create middleware chain - each middleware gets the store and can access baseApi
-    const chain = middlewares.map((middleware) => middleware(middlewareStore))
-
-    // Compose the middleware chain to create enhanced dispatch
-    dispatch = compose(...chain)(store.dispatch)
-
-    // Return enhanced API that external code will use
-    return {
-      ...middlewareStore,
-      // Override dispatch/notify with the middleware-enhanced versions
-      dispatch,
-      notify: (type, payload) => dispatch({ type, payload }),
-    }
-  }
+export function applyMiddlewares(store, middlewares) {
+  return middlewares.reduceRight(
+    (wrapped, middleware) => middleware(wrapped),
+    store,
+  )
 }

package/src/store.js

@@ -42,7 +42,8 @@ const UPDATE_STRATEGIES = [STRUCTURAL_SHARING, COPY_ON_DISPATCH]
  * @param {Types} [config.types] - The initial types configuration.
  * @param {Entities} [config.entities] - The initial entities configuration.
  * @param {Object[]} [config.systems] - The initial systems configuration.
- * @param {Function[]} [config.middlewares] - The initial middlewares configuration.
+ * @param {Function[]} [config.middlewares] - Functions that each take the store and return it,
+ *   changed or wrapped. The first wraps all the others, so events pass through them in order.
  * @param {boolean} [config.autoCreateEntities=false] - Creates entities if not defined in `config.entities`.
  * @param {"auto" | "manual"} [config.updateMode="auto"] - Whether each event triggers an update, or updates are batched until `update()` is called.
  * @param {UpdateStrategy} [config.updateStrategy="structural-sharing"] - How the state is copied before events are applied.
@@ -81,9 +82,7 @@ export function createStore({
     reset,
   }
 
-  const store = middlewares.length
-    ? applyMiddlewares(...middlewares)(baseStore)
-    : baseStore
+  const store = applyMiddlewares(baseStore, middlewares)
   const api = createApi(store, store.extras)
   store._api = api
 

package/types/store.d.ts

@@ -223,7 +223,9 @@ export interface Store<
 }
 
 /**
- * Middleware function type
+ * Middleware function type: takes the store and returns it, changed or wrapped. One that
+ * only looks at events replaces `dispatch` with a function that calls the previous one.
+ * The first middleware wraps all the others, so events pass through them in order.
  */
 export type Middleware<
   TEntity extends BaseEntity = BaseEntity,