@woosh/meep-engine 2.37.1 → 2.37.2

package/core/process/undo/ActionProcessor.js

@@ -9,7 +9,6 @@ import List from "../../collection/list/List.js";
 import Signal from "../../events/signal/Signal.js";
 import { min2 } from "../../math/min2.js";
 import { Mark } from "./Mark.js";
-import { IllegalStateException } from "../../fsm/exceptions/IllegalStateException.js";
 
 /**
  * @template C, M
@@ -75,13 +74,6 @@ export class ActionProcessor {
          */
         this.onMarkRemoved = new Signal();
 
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__action_in_progress = false;
-
         /**
          *
          * @type {Promise<never>}
@@ -172,10 +164,8 @@ export class ActionProcessor {
      * Insert a mark into the timeline, all actions between marks are grouped logically for UNDO and REDO mechanism
      * @param {D} description
      */
-    mark(description) {
-        if (this.__action_in_progress) {
-            throw new IllegalStateException('Action is currently in progress');
-        }
+    async mark(description) {
+        await this.__barrier();
 
         const marks = this.marks;
         const numMarks = marks.length;
@@ -265,6 +255,24 @@ export class ActionProcessor {
      * @throws {Error} when mark is non-unique
      */
     async navigateTo(mark_descriptor) {
+        await this.__barrier();
+
+        const p = this.__unsafe_navigateTo(mark_descriptor);
+
+        this.__last_promise = p;
+
+        return await p;
+    }
+
+    /**
+     * Navigate to a specific mark back or forward
+     * @param {M} mark_descriptor specific mark description
+     * @returns {boolean} true on success, false otherwise (e.g. mark not found)
+     * @throws {Error} when mark is non-unique
+     * @private
+     */
+    async __unsafe_navigateTo(mark_descriptor) {
+
         // find all matching marks
         const matching_marks = this.__find_mark_indices_by_description(mark_descriptor);
 
@@ -293,7 +301,7 @@ export class ActionProcessor {
 
             while (target > this.cursor) {
                 // navigate forward
-                await this.redo();
+                await this.__unsafe_redo();
 
                 if (temp_cursor === this.cursor) {
                     // no cursor change
@@ -307,7 +315,7 @@ export class ActionProcessor {
 
             while (target < this.cursor) {
                 // navigate backwards
-                await this.undo();
+                await this.__unsafe_undo();
 
                 if (temp_cursor === this.cursor) {
                     // no cursor change
@@ -323,6 +331,21 @@ export class ActionProcessor {
     }
 
     async undo() {
+        await this.__barrier();
+
+        const p = this.__unsafe_undo();
+
+        this.__last_promise = p;
+
+        await p;
+    }
+
+    /**
+     *
+     * @returns {Promise<void>}
+     * @private
+     */
+    async __unsafe_undo() {
         let markAddress = 0;
         /**
          *
@@ -351,7 +374,7 @@ export class ActionProcessor {
             this.cursor--;
             const action = this.history.get(this.cursor);
 
-            await this.__action_revert(action);
+            await action.revert(this.context);
         }
 
         if (mark !== null) {
@@ -363,8 +386,23 @@ export class ActionProcessor {
      * redo previous sequence of actions on the timeline, up to the next mark
      */
     async redo() {
+        await this.__barrier();
+
+        const p = this.__unsafe_redo();
 
+        this.__last_promise = p;
+
+        await p;
+    }
+
+    /**
+     *
+     * @returns {Promise<void>}
+     * @private
+     */
+    async __unsafe_redo() {
         let mark = this.history.length;
+
         //find mark
         const marks = this.marks;
 
@@ -382,7 +420,7 @@ export class ActionProcessor {
         while (this.cursor < mark) {
             const action = this.history.get(this.cursor);
 
-            await this.__action_apply(action);
+            await action.apply(this.context);
 
             this.historyMemoryUsage += action.computeByteSize();
 
@@ -395,15 +433,26 @@ export class ActionProcessor {
      * @param {Action[]} actions
      */
     async doMany(actions) {
-        const n = actions.length;
+        await this.__barrier();
 
-        for (let i = 0; i < n; i++) {
+        const p = new Promise(async (resolve, reject) => {
 
-            const action = actions[i];
+            const n = actions.length;
 
-            await this.do(action);
+            for (let i = 0; i < n; i++) {
 
-        }
+                const action = actions[i];
+
+                await this.__unsafe_do(action);
+
+            }
+
+            resolve();
+        });
+
+        this.__last_promise = p;
+
+        await p;
     }
 
     /**
@@ -411,21 +460,13 @@ export class ActionProcessor {
      * @param {Action} action
      */
     async do(action) {
-        await this.__action_apply(action);
+        await this.__barrier();
 
-        this.historyMemoryUsage += action.computeByteSize();
+        const p = this.__unsafe_do(action);
 
-        const history = this.history;
+        this.__last_promise = p;
 
-        //doing action invalidates "future" branch of history, we need to clear all actions beyond cursor
-        if (this.cursor < history.length) {
-            history.crop(0, this.cursor);
-            // TODO clear future marks
-        }
-
-        history.add(action);
-
-        this.cursor++;
+        await p;
     }
 
     /**
@@ -434,63 +475,34 @@ export class ActionProcessor {
      * @returns {Promise<void>}
      * @private
      */
-    async __action_apply(action) {
-        try {
-            await this.__last_promise;
-        } catch (e) {
-            // ignore
-        }
+    async __unsafe_do(action) {
+        await action.apply(this.context);
 
-        if (this.__action_in_progress) {
-            throw new IllegalStateException();
-        }
+        this.historyMemoryUsage += action.computeByteSize();
 
-        this.__action_in_progress = true;
+        const history = this.history;
 
-        let p;
-        try {
-            p = action.apply(this.context);
-        } finally {
-            this.__action_in_progress = false;
+        //doing action invalidates "future" branch of history, we need to clear all actions beyond cursor
+        if (this.cursor < history.length) {
+            history.crop(0, this.cursor);
+            // TODO clear future marks
         }
 
-        if (p !== undefined) {
-            this.__last_promise = p;
-            await p;
-        }
+        history.add(action);
 
+        this.cursor++;
     }
 
     /**
-     *
-     * @param {Action} action
+     * Await for synchronization barrier
      * @returns {Promise<void>}
      * @private
      */
-    async __action_revert(action) {
+    async __barrier() {
         try {
             await this.__last_promise;
         } catch (e) {
             // ignore
         }
-
-        if (this.__action_in_progress) {
-            throw new IllegalStateException();
-        }
-
-        this.__action_in_progress = true;
-
-        let p;
-        try {
-            p = action.revert(this.context);
-        } finally {
-            this.__action_in_progress = false;
-        }
-
-        if (p !== undefined) {
-            this.__last_promise = p;
-            await p;
-        }
-
     }
 }

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.37.1",
+  "version": "2.37.2",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",