Migrate to immutability pattern

Author: RDIL

build.mjs

@@ -16,26 +16,15 @@
 
 import esbuild, { analyzeMetafile } from "esbuild"
 
-const sharedSettings = {
+const esm = await esbuild.build({
     entryPoints: ["src/index.ts"],
     bundle: true,
     write: true,
     outdir: "build",
     metafile: true,
     sourcemap: true,
-}
-
-const esm = await esbuild.build({
-    ...sharedSettings,
     format: "esm",
+    external: ["mutative"],
 })
 
 console.log(await analyzeMetafile(esm.metafile))
-
-const cjs = await esbuild.build({
-    ...sharedSettings,
-    format: "cjs",
-    entryNames: "index-cjs"
-})
-
-console.log(await analyzeMetafile(cjs.metafile))

package.json

@@ -2,13 +2,13 @@
     "name": "@peacockproject/statemachine-parser",
     "version": "6.2.0",
     "description": "IOI state machine conditional parser.",
-    "main": "build/index-cjs.js",
-    "module": "build/index.js",
+    "type": "module",
+    "main": "build/index.js",
     "types": "build/index.d.ts",
     "homepage": "https://thepeacockproject.org",
     "sideEffects": false,
     "engines": {
-        "node": ">=16.3.0"
+        "node": ">=20"
     },
     "directories": {
         "test": "tests",
@@ -65,5 +65,8 @@
     },
     "publishConfig": {
         "access": "public"
+    },
+    "dependencies": {
+        "mutative": "^1.3.0"
     }
 }

src/handleEvent.ts

@@ -14,14 +14,16 @@
  *    limitations under the License.
  */
 
-import { handleActions, test } from "./index"
-import { deepClone, findNamedChild, set } from "./utils"
+import { test, handleActionsOnDraft } from "./index"
+import { findNamedChild } from "./utils"
 import {
     HandleEventOptions,
     HandleEventReturn,
     InStateEventHandler,
     StateMachineLike,
 } from "./types"
+import { create } from "mutative"
+
 
 /**
  * This function simulates an event happening, as if in game.
@@ -63,7 +65,7 @@ export function handleEvent<Context = unknown, Event = unknown>(
     const hasTimerState = !!csObject.$timer
 
     // ensure no circular references are present, and that this won't update the param by accident
-    let newContext = deepClone(context)
+    let newContext = context
 
     const doEventHandler = (handler: InStateEventHandler) => {
         // do we need to check conditions?
@@ -100,12 +102,17 @@ export function handleEvent<Context = unknown, Event = unknown>(
                 },
                 {
                     pushUniqueAction(reference, item) {
-                        const referenceArray = findNamedChild(
-                            reference,
-                            newContext,
-                            true,
-                        )
-                        item = findNamedChild(item, newContext, false)
+                        const workingContext = {
+                            ...newContext,
+                            ...(definition.Constants || {}),
+                            ...(options.contractId && {
+                                ContractId: options.contractId,
+                            }),
+                            Value: event,
+                        }
+                        
+                        const referenceArray = findNamedChild(reference, workingContext, true)
+                        item = findNamedChild(item, workingContext, false)
                         log(
                             "action",
                             `Running pushUniqueAction on ${reference} with ${item}`,
@@ -119,9 +126,13 @@ export function handleEvent<Context = unknown, Event = unknown>(
                             return false
                         }
 
-                        referenceArray.push(item)
-
-                        set(newContext, reference, referenceArray)
+                        // Actually modify the context using Mutative
+                        newContext = create(newContext, (draft) => {
+                            const draftArray = findNamedChild(reference, draft, true)
+                            if (Array.isArray(draftArray) && !draftArray.includes(item)) {
+                                draftArray.push(item)
+                            }
+                        })
 
                         return true
                     },
@@ -147,43 +158,52 @@ export function handleEvent<Context = unknown, Event = unknown>(
                 )
             }
 
-            for (const actionSet of Actions as unknown[]) {
-                for (const action of Object.keys(actionSet)) {
-                    newContext = handleActions(
-                        {
-                            [action]: actionSet[action],
-                        },
-                        {
-                            ...newContext,
-                            ...(definition.Constants || {}),
-                            ...(options.contractId && {
-                                ContractId: options.contractId,
-                            }),
-                            Value: event,
-                        },
-                        {
-                            originalContext: definition.Context ?? {},
-                        },
-                    )
-                }
+            // Special case: if the handler itself contains action keys and no Actions property,
+            // treat the handler as the actions
+            if (!handler.Actions && hasIrregularEventKeys) {
+                Actions = [handler]
             }
 
-            // drop this specific event's value
-            if (newContext.hasOwnProperty("Value")) {
-                // @ts-expect-error
-                delete newContext.Value
+            // Create a working context with constants and event data
+            const workingContext = {
+                ...newContext,
+                ...(definition.Constants || {}),
+                ...(options.contractId && {
+                    ContractId: options.contractId,
+                }),
+                Value: event,
             }
 
-            // drop this specific event's ContractId
-            if (newContext.hasOwnProperty("ContractId")) {
-                // @ts-expect-error
-                delete newContext.ContractId
-            }
+            newContext = create(workingContext, (draft) => {
+                for (const actionSet of Actions as unknown[]) {
+                    // For each action in the action set, apply it individually
+                    for (const actionKey of Object.keys(actionSet)) {
+                        handleActionsOnDraft(
+                            { [actionKey]: actionSet[actionKey] },
+                            draft,
+                            draft, // Use the draft for reading values so each action sees previous changes
+                            {
+                                originalContext: definition.Context ?? {}
+                            }
+                        )
+                    }
+                }
 
-            // drop the constants
-            for (const constantKey of constantKeys) {
-                delete newContext[constantKey]
-            }
+                // drop this specific event's value
+                if (draft.hasOwnProperty("Value")) {
+                    delete draft.Value
+                }
+
+                // drop this specific event's ContractId
+                if (draft.hasOwnProperty("ContractId")) {
+                    delete draft.ContractId
+                }
+
+                // drop the constants
+                for (const constantKey of constantKeys) {
+                    delete draft[constantKey]
+                }
+            })
         }
 
         let state = currentState

src/index.ts

@@ -18,6 +18,7 @@ import { handleEvent } from "./handleEvent"
 import { HandleActionsOptions, TestOptions } from "./types"
 import { deepClone, findNamedChild, set } from "./utils"
 import { handleArrayLogic } from "./arrayHandling"
+import { create } from "mutative"
 
 /**
  * Recursively evaluate a value or object.
@@ -333,33 +334,52 @@ export function handleActions<Context>(
         return context
     }
 
+    return create(context, (draft) => {
+        handleActionsOnDraft(input, draft, context, options)
+    })
+}
+
+/**
+ * Internal function that applies actions directly to a draft object.
+ * This is used both by handleActions and handleEvent to avoid code duplication.
+ */
+export function handleActionsOnDraft<Context>(
+    input: any,
+    draft: any,
+    originalContext: Context,
+    options?: HandleActionsOptions,
+): void {
+    if (!input || typeof input !== "object") {
+        return
+    }
+
     const addOrDec = (op: string) => {
         if (typeof input[op] === "string") {
             let reference = input[op]
 
-            const variableValue = findNamedChild(input[op], context, true)
+            const variableValue = findNamedChild(input[op], originalContext, true)
 
             if (typeof variableValue !== "number") {
                 return
             }
 
             set(
-                context,
+                draft,
                 reference,
                 op === "$inc" ? variableValue + 1 : variableValue - 1,
             )
         } else {
             let reference = input[op][0]
 
-            const variableValue = findNamedChild(reference, context, true)
-            const incrementBy = findNamedChild(input[op][1], context, false)
+            const variableValue = findNamedChild(reference, originalContext, true)
+            const incrementBy = findNamedChild(input[op][1], originalContext, false)
 
             if (typeof variableValue !== "number") {
                 return
             }
 
             set(
-                context,
+                draft,
                 reference,
                 op === "$inc"
                     ? variableValue + incrementBy
@@ -376,10 +396,10 @@ export function handleActions<Context>(
             reference = reference.substring(1)
         }
 
-        const value = findNamedChild(input[op][1], context, false)
+        const value = findNamedChild(input[op][1], originalContext, false)
 
         // clone the thing
-        const array = deepClone(findNamedChild(reference, context, true))
+        const array = deepClone(findNamedChild(reference, originalContext, true))
 
         if (!Array.isArray(array)) {
             return
@@ -395,7 +415,7 @@ export function handleActions<Context>(
             array.push(value)
         }
 
-        set(context, reference, array)
+        set(draft, reference, array)
     }
 
     for (const key of Object.keys(input)) {
@@ -416,12 +436,12 @@ export function handleActions<Context>(
                 // Therefore the 1st operand might get written to, but the 2nd one is purely a read.
                 const variableValue1 = findNamedChild(
                     input["$mul"][0],
-                    context,
+                    originalContext,
                     true,
                 )
                 const variableValue2 = findNamedChild(
                     input["$mul"][1],
-                    context,
+                    originalContext,
                     false,
                 )
 
@@ -432,15 +452,15 @@ export function handleActions<Context>(
                     break
                 }
 
-                set(context, reference, variableValue1 * variableValue2)
+                set(draft, reference, variableValue1 * variableValue2)
                 break
             }
             case "$set": {
                 let reference = input.$set[0]
 
-                const value = findNamedChild(input.$set[1], context, false)
+                const value = findNamedChild(input.$set[1], originalContext, false)
 
-                set(context, reference, value)
+                set(draft, reference, value)
                 break
             }
             case "$push": {
@@ -458,11 +478,11 @@ export function handleActions<Context>(
                     reference = reference.substring(1)
                 }
 
-                const value = findNamedChild(input.$remove[1], context, false)
+                const value = findNamedChild(input.$remove[1], originalContext, false)
 
                 // clone the thing
                 let array: unknown[] = deepClone(
-                    findNamedChild(reference, context, true),
+                    findNamedChild(reference, originalContext, true),
                 )
 
                 if (!Array.isArray(array)) {
@@ -471,24 +491,22 @@ export function handleActions<Context>(
 
                 array = array.filter((item) => item !== value)
 
-                set(context, reference, array)
+                set(draft, reference, array)
                 break
             }
             case "$reset": {
                 let reference = input.$reset
                 const value = findNamedChild(
                     reference,
-                    options.originalContext,
+                    options?.originalContext,
                     true,
                 )
 
-                set(context, reference, value)
+                set(draft, reference, value)
                 break
             }
         }
     }
-
-    return context
 }
 
 export { handleEvent }

yarn.lock

@@ -272,6 +272,7 @@ __metadata:
     esbuild-register: "npm:^3.5.0"
     get-package-type: "npm:^0.1.0"
     mocha: "npm:^10.4.0"
+    mutative: "npm:^1.3.0"
     prettier: "npm:^3.3.2"
     typescript: "npm:^5.5.2"
   languageName: unknown
@@ -1505,6 +1506,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"mutative@npm:^1.3.0":
+  version: 1.3.0
+  resolution: "mutative@npm:1.3.0"
+  checksum: 10/1e38ea5212f3410e2e62fb71ab5ff9c9efb9327b8e62aa77ca5faf8cea8304ddb7c21d2e586323ac7e5048c8c8eebb8187b2e9347e348e60d6841cfe14ed05a0
+  languageName: node
+  linkType: hard
+
 "negotiator@npm:^0.6.3":
   version: 0.6.3
   resolution: "negotiator@npm:0.6.3"