@inglorious/store 9.5.2 → 9.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inglorious/store",
-  "version": "9.5.2",
+  "version": "9.5.3",
   "description": "A state manager for real-time, collaborative apps, inspired by game development patterns and compatible with Redux.",
   "author": "IceOnFire <antony.mistretta@gmail.com> (https://ingloriouscoderz.it)",
   "license": "MIT",
@@ -62,6 +62,7 @@
     "@inglorious/utils": "3.7.3"
   },
   "devDependencies": {
+    "@reduxjs/toolkit": "^2.11.2",
     "prettier": "^3.6.2",
     "vite": "^7.1.3",
     "vitest": "^1.6.1",

package/src/migration/rtk.js

@@ -5,11 +5,14 @@
  * Inglorious types, enabling gradual migration from RTK to Inglorious Store.
  */
 
+import { extend } from "@inglorious/utils/data-structures/objects.js"
+
 import { handleAsync } from "../async"
 
 const SEP_LENGTH = 50
 const INDENT_SPACES = 2
 const SLICE_PLUS_ACTION = 2
+const THUNK_STAGES = ["pending", "fulfilled", "rejected", "settled"]
 
 /**
  * Converts an RTK createAsyncThunk to Inglorious handleAsync handlers
@@ -50,7 +53,7 @@ const SLICE_PLUS_ACTION = 2
  *
  * // Use in type
  * const todoList = {
- *   init(entity) { entity.todos = []; entity.status = 'idle' },
+ *   create(entity) { entity.todos = []; entity.status = 'idle' },
  *   ...todoHandlers
  * }
  */
@@ -74,8 +77,16 @@ export function convertAsyncThunk(name, payloadCreator, options = {}) {
 
       run: async (payload, api) => {
         // RTK payloadCreator signature: (arg, thunkAPI)
-        // We need to adapt it to our simpler signature
-        return await payloadCreator(payload, { dispatch: api.notify })
+        // Use dispatch for action compatibility, with notify fallback in tests/minimal APIs.
+        const dispatch = api.dispatch
+          ? api.dispatch.bind(api)
+          : (action) => {
+              if (typeof action === "object" && action !== null) {
+                api.notify(action.type, action.payload)
+              }
+            }
+
+        return await payloadCreator(payload, { dispatch })
       },
 
       success: onFulfilled
@@ -156,19 +167,88 @@ export function convertAsyncThunk(name, payloadCreator, options = {}) {
  * })
  */
 export function convertSlice(slice, options = {}) {
-  const { asyncThunks = {}, extraHandlers = {} } = options
+  const { asyncThunks = {}, extraHandlers = {}, extraActions = [] } = options
 
   const type = {
-    // Convert initialState to init handler
-    init(entity) {
+    // Convert initialState to create handler.
+    // Preserve explicitly preloaded fields from entities (common in tests/SSR hydration).
+    create(entity) {
       const initialState = slice.getInitialState()
-      Object.assign(entity, initialState)
+      Object.assign(entity, extend(initialState, entity))
     },
   }
 
   // Convert each reducer to an event handler
   for (const [actionName, reducer] of Object.entries(slice.caseReducers)) {
-    type[actionName] = (entity, payload) => {
+    const thunkConfig = asyncThunks[actionName]
+    const isAsyncThunkReducer =
+      reducer &&
+      typeof reducer === "object" &&
+      THUNK_STAGES.some((stage) => typeof reducer[stage] === "function")
+
+    if (isAsyncThunkReducer) {
+      const pending = toLifecycleHandler(
+        slice.name,
+        actionName,
+        "pending",
+        reducer.pending,
+      )
+      const fulfilled = toLifecycleHandler(
+        slice.name,
+        actionName,
+        "fulfilled",
+        reducer.fulfilled,
+      )
+      const rejected = toLifecycleHandler(
+        slice.name,
+        actionName,
+        "rejected",
+        reducer.rejected,
+      )
+      const settled = toLifecycleHandler(
+        slice.name,
+        actionName,
+        "settled",
+        reducer.settled,
+      )
+
+      if (thunkConfig?.payloadCreator) {
+        const asyncHandlers = convertAsyncThunk(
+          actionName,
+          thunkConfig.payloadCreator,
+          {
+            onPending: thunkConfig.onPending || pending,
+            onFulfilled: thunkConfig.onFulfilled || fulfilled,
+            onRejected: thunkConfig.onRejected || rejected,
+            onSettled: thunkConfig.onSettled || settled,
+            scope: thunkConfig.scope,
+          },
+        )
+
+        Object.assign(type, asyncHandlers)
+      } else {
+        if (pending) {
+          type[`${actionName}Pending`] = pending
+          type[`${slice.name}/${actionName}/pending`] = pending
+        }
+        if (fulfilled) {
+          type[`${actionName}Fulfilled`] = fulfilled
+          type[`${slice.name}/${actionName}/fulfilled`] = fulfilled
+        }
+        if (rejected) {
+          type[`${actionName}Rejected`] = rejected
+          type[`${slice.name}/${actionName}/rejected`] = rejected
+        }
+        if (settled) {
+          type[`${actionName}Settled`] = settled
+          type[`${slice.name}/${actionName}/settled`] = settled
+        }
+      }
+
+      continue
+    }
+
+    const handler = (entity, payload) => {
       // Create a mock action object for the RTK reducer
       const action = { type: `${slice.name}/${actionName}`, payload }
 
@@ -177,23 +257,42 @@ export function convertSlice(slice, options = {}) {
       // So we can call the reducer directly on the entity
       reducer(entity, action)
     }
+
+    // Expose both Inglorious-style event names and RTK action-type aliases.
+    // This enables direct dispatch of RTK slice actions without extra bridge wiring.
+    type[actionName] = handler
+    type[`${slice.name}/${actionName}`] = handler
   }
 
-  // Convert async thunks
+  // Convert explicitly configured async thunks that are not embedded in slice reducers.
   for (const [thunkName, thunkHandlers] of Object.entries(asyncThunks)) {
-    const asyncHandlers = convertAsyncThunk(
-      thunkName,
-      thunkHandlers.payloadCreator || (async () => {}),
-      {
-        onPending: thunkHandlers.onPending,
-        onFulfilled: thunkHandlers.onFulfilled,
-        onRejected: thunkHandlers.onRejected,
-        onSettled: thunkHandlers.onSettled,
-        scope: thunkHandlers.scope,
-      },
-    )
+    if (thunkHandlers?.payloadCreator && !type[thunkName]) {
+      const asyncHandlers = convertAsyncThunk(
+        thunkName,
+        thunkHandlers.payloadCreator,
+        {
+          onPending: thunkHandlers.onPending,
+          onFulfilled: thunkHandlers.onFulfilled,
+          onRejected: thunkHandlers.onRejected,
+          onSettled: thunkHandlers.onSettled,
+          scope: thunkHandlers.scope,
+        },
+      )
+
+      Object.assign(type, asyncHandlers)
+    }
+  }
 
-    Object.assign(type, asyncHandlers)
+  // Register additional RTK action types (e.g. createAction + extraReducers).
+  // RTK does not expose extraReducers through slice.caseReducers, so callers can
+  // provide the action creators/types explicitly and we route them through slice.reducer.
+  for (const action of extraActions) {
+    const actionType = typeof action === "string" ? action : action?.type
+    if (typeof actionType !== "string" || type[actionType]) continue
+
+    type[actionType] = (entity, payload) => {
+      applySliceReducer(entity, slice, actionType, payload)
+    }
   }
 
   // Add any extra handlers
@@ -324,3 +423,44 @@ export function createRTKCompatDispatch(api, entityId) {
     }
   }
 }
+
+function createActionObject(sliceName, actionName, stage, payload) {
+  const action = {
+    type: `${sliceName}/${actionName}/${stage}`,
+    payload,
+    meta: { arg: payload },
+  }
+
+  if (stage === "pending") {
+    action.payload = undefined
+  }
+
+  if (stage === "rejected") {
+    action.error = payload
+  }
+
+  return action
+}
+
+function toLifecycleHandler(sliceName, actionName, stage, reducer) {
+  if (typeof reducer !== "function") return undefined
+
+  return (entity, payload) => {
+    reducer(entity, createActionObject(sliceName, actionName, stage, payload))
+  }
+}
+
+function applySliceReducer(entity, slice, actionType, payload) {
+  const action = { type: actionType, payload }
+  const nextState = slice.reducer(toPlainState(entity), action)
+
+  for (const key of Object.keys(entity)) {
+    delete entity[key]
+  }
+
+  Object.assign(entity, nextState)
+}
+
+function toPlainState(entity) {
+  return JSON.parse(JSON.stringify(entity))
+}

package/types/migration/rtk.d.ts

@@ -147,6 +147,12 @@ export interface ConvertSliceOptions<TEntity extends BaseEntity = BaseEntity> {
     string,
     (entity: TEntity, payload?: any, api?: Api) => void
   >
+
+  /**
+   * Additional RTK actions to map (useful for createAction + extraReducers).
+   * Accepts action creators (with a `type` field) or raw action type strings.
+   */
+  extraActions?: Array<string | { type: string }>
 }
 
 /**
@@ -156,7 +162,7 @@ export interface InglorisousType<TEntity extends BaseEntity = BaseEntity> {
   /**
    * Initialization handler
    */
-  init?: (entity: TEntity, payload?: any, api?: Api) => void
+  create?: (entity: TEntity, payload?: any, api?: Api) => void
 
   /**
    * Other event handlers