@woosh/meep-engine 2.110.15 → 2.111.0

package/src/core/events/signal/Signal.js

@@ -1,17 +1,8 @@
 import { assert } from "../../assert.js";
-import { dispatchViaProxy } from "./dispatchViaProxy.js";
-import { findSignalHandlerIndexByHandle } from "./findSignalHandlerIndexByHandle.js";
-import { findSignalHandlerIndexByHandleAndContext } from "./findSignalHandlerIndexByHandleAndContext.js";
+import { signal_handler_list_find } from "./signal_handler_list_find.js";
 import { SignalFlags } from "./SignalFlags.js";
 import { SignalHandler, SignalHandlerFlags } from "./SignalHandler.js";
 
-/**
- * Common dispatch stack
- * @readonly
- * @type {SignalHandler[]}
- */
-const dispatch_stack = [];
-let dispatch_stack_top = 0;
 
 /**
  * Signal is a type of event bus. You can subscribe to events using {@link add} method and dispatch using sendN method where N is the number of arguments you wish to pass
@@ -20,10 +11,11 @@ let dispatch_stack_top = 0;
  */
 export class Signal {
     /**
+     * Map is used to speed up lookup when removing handlers in case of large number of listeners.
      * @private
-     * @type {SignalHandler[]}
+     * @type {Map<function,SignalHandler>}
      */
-    handlers = [];
+    handlers = new Map();
 
     /**
      * Internal flag bitmask
@@ -100,9 +92,15 @@ export class Signal {
     contains(handler, thisArg) {
         const handlers = this.handlers;
 
-        const i = findSignalHandlerIndexByHandle(handlers, handler, thisArg);
+        const sh = handlers.get(handler);
+
+        if (sh === undefined) {
+            return false;
+        }
 
-        return i !== -1;
+        const existing = signal_handler_list_find(sh, handler, thisArg);
+
+        return existing !== null;
     }
 
     mute() {
@@ -118,7 +116,7 @@ export class Signal {
      * @returns {boolean}
      */
     hasHandlers() {
-        return this.handlers.length > 0;
+        return this.handlers.size > 0;
     }
 
     /**
@@ -133,7 +131,7 @@ export class Signal {
 
         handler.setFlag(SignalHandlerFlags.RemoveAfterExecution);
 
-        this.handlers.push(handler);
+        this.#add_handler(handler);
     }
 
     /**
@@ -144,15 +142,36 @@ export class Signal {
     add(h, context) {
         assert.isFunction(h, "handler");
 
-        // if (!ENV_PRODUCTION) {
-        //     if (this.handlers.length + 1 === 100) {
-        //         console.error(`Number of handlers has is 100 now, possible leak detected`);
-        //     }
-        // }
-
         const handler = new SignalHandler(h, context);
 
-        this.handlers.push(handler);
+        this.#add_handler(handler);
+
+    }
+
+    /**
+     *
+     * @param {SignalHandler} handler
+     */
+    #add_handler(handler) {
+
+        const f = handler.handle;
+        const first = this.handlers.get(f);
+
+        if (first === undefined) {
+            this.handlers.set(f, handler);
+        } else {
+
+            handler.next = first;
+            this.handlers.set(f,handler);
+
+            // const last = signal_handler_list_last(first);
+
+            // last.next = handler;
+
+            // assert.ok(signal_handler_list_validate(first, console.error), 'invalid configuration');
+
+        }
+
     }
 
     /**
@@ -164,11 +183,44 @@ export class Signal {
     remove(h, thisArg) {
         assert.isFunction(h, "handler");
 
-        if (thisArg === undefined) {
-            return removeHandlerByHandler(this, h);
-        } else {
-            return removeHandlerByHandlerAndContext(this, h, thisArg);
+        const first = this.handlers.get(h);
+
+        if (first === undefined) {
+            return false;
         }
+
+        if (first.handle === h && first.context === thisArg) {
+            if (first.next === null) {
+                this.handlers.delete(h);
+            } else {
+                this.handlers.set(h, first.next)
+                // assert.ok(signal_handler_list_validate(first.next, console.error), 'invalid configuration');
+            }
+
+            return true;
+        }
+
+        let previous = first;
+        let n = first.next;
+
+        while (n !== null) {
+
+            if (n.handle === h && n.context === thisArg) {
+
+                previous.next = n.next;
+
+                // assert.ok(signal_handler_list_validate(first, console.error), 'invalid configuration');
+
+                return true;
+
+            }
+
+            previous = n;
+            n = n.next;
+
+        }
+
+        return false;
     }
 
     /**
@@ -179,8 +231,58 @@ export class Signal {
      * @deprecated
      */
     removeAll() {
-        const handlers = this.handlers;
-        handlers.splice(0, handlers.length);
+        this.handlers.clear();
+    }
+
+    /**
+     *
+     * @param {SignalHandler} handler
+     */
+    #remove_handler_internal(handler) {
+
+        const first = this.handlers.get(handler.handle);
+
+        if (first === undefined) {
+            // nothing
+            return false;
+        }
+
+        // special case for first
+        if (first === handler) {
+
+            if (first.next === null) {
+                // was the only one
+                this.handlers.delete(handler.handle);
+            } else {
+                this.handlers.set(handler.handle, first.next);
+                // assert.ok(signal_handler_list_validate(first.next, console.error), 'invalid configuration');
+            }
+
+            return true;
+        }
+
+        let previous = first;
+        let n = first.next;
+
+        while (n !== null) {
+
+            const next = n.next;
+
+            if (n === handler) {
+                previous.next = next;
+
+                // assert.ok(signal_handler_list_validate(first, console.error), 'invalid configuration');
+
+                return true;
+            }
+
+            previous = n;
+            n = next;
+
+        }
+
+        // not found
+        return false;
     }
 
     /**
@@ -193,10 +295,39 @@ export class Signal {
             return;
         }
 
-        dispatchViaProxy(this.handlers, args);
+        const handlers = this.handlers;
+
+        for (const handle of handlers.values()) {
+
+            let _h = handle;
+
+            do {
+
+                const next = _h.next;
+
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
+
+                const _f = _h.handle;
+
+                try {
+                    _f.apply(_h.context, args)
+                } catch (e) {
+                    console.error("Failed to dispatch handler", _f, e);
+                }
+
+                _h = next;
+
+            } while (_h !== null);
+
+
+        }
 
     }
 
+
     /**
      * dispatch without a value.
      * Allows JS engine to optimize for monomorphic call sites
@@ -209,42 +340,34 @@ export class Signal {
 
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, h;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
 
-            const f = h.handle;
+                try {
+                    _f.call(_h.context)
+                } catch (e) {
+                    console.error("Failed to dispatch handler", _f, e);
+                }
+
+                _h = next;
+
+            } while (_h !== null);
 
-            try {
-                f.call(h.context)
-            } catch (e) {
-                console.error("Failed to dispatch handler", f, e);
-            }
 
         }
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
     }
 
     /**
@@ -260,43 +383,34 @@ export class Signal {
 
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
+            do {
 
-        let i, h;
+                const next = _h.next;
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                const _f = _h.handle;
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                try {
+                    _f.call(_h.context, arg)
+                } catch (e) {
+                    console.error("Failed to dispatch handler", _f, e);
+                }
 
-            const f = h.handle;
+                _h = next;
+
+            } while (_h !== null);
 
-            try {
-                f.call(h.context, arg)
-            } catch (e) {
-                console.error("Failed to dispatch handler", f, e);
-            }
 
         }
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
     }
 
     /**
@@ -312,42 +426,33 @@ export class Signal {
 
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, h;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
 
-            const f = h.handle;
+                try {
+                    _f.call(_h.context, a, b)
+                } catch (e) {
+                    console.error("Failed to dispatch handler", _f, e);
+                }
 
-            try {
-                f.call(h.context, a, b)
-            } catch (e) {
-                console.error("Failed to dispatch handler", f, e);
-            }
+                _h = next;
 
-        }
+            } while (_h !== null);
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
+
+        }
     }
 
     /**
@@ -362,44 +467,36 @@ export class Signal {
             return;
         }
 
+
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, h;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
 
-            const f = h.handle;
+                try {
+                    _f.call(_h.context, a, b, c)
+                } catch (e) {
+                    console.error("Failed to dispatch handler", _f, e);
+                }
 
-            try {
-                f.call(h.context, a, b, c)
-            } catch (e) {
-                console.error("Failed to dispatch handler", f, e);
-            }
+                _h = next;
+
+            } while (_h !== null);
 
-        }
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
+        }
     }
 
     /**
@@ -415,44 +512,36 @@ export class Signal {
             return;
         }
 
+
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, h;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
 
-            const f = h.handle;
+                try {
+                    _f.call(_h.context, a, b, c, d)
+                } catch (e) {
+                    console.error("Failed to dispatch handler", _f, e);
+                }
 
-            try {
-                f.call(h.context, a, b, c, d)
-            } catch (e) {
-                console.error("Failed to dispatch handler", f, e);
-            }
+                _h = next;
+
+            } while (_h !== null);
 
-        }
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
+        }
     }
 
     /**
@@ -470,44 +559,36 @@ export class Signal {
             return;
         }
 
+
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, h;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
 
-            const handle = h.handle;
+                try {
+                    _f.call(_h.context, a, b, c, d, e, f)
+                } catch (e) {
+                    console.error("Failed to dispatch handler", f, e);
+                }
 
-            try {
-                handle.call(h.context, a, b, c, d, e, f)
-            } catch (e) {
-                console.error("Failed to dispatch handler", handle, e);
-            }
+                _h = next;
 
-        }
+            } while (_h !== null);
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
+
+        }
     }
 
     /**
@@ -529,42 +610,33 @@ export class Signal {
 
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, handler;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            handler = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (handler.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(handler);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
 
-            const handle = handler.handle;
+                try {
+                    _f.call(_h.context, a, b, c, d, e, f, g, h)
+                } catch (e) {
+                    console.error("Failed to dispatch handler", f, e);
+                }
 
-            try {
-                handle.call(handler.context, a, b, c, d, e, f, g, h)
-            } catch (e) {
-                console.error("Failed to dispatch handler", handle, e);
-            }
+                _h = next;
 
-        }
+            } while (_h !== null);
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
+
+        }
     }
 
     /**
@@ -593,42 +665,4 @@ export class Signal {
  */
 Signal.prototype.isSignal = true;
 
-/**
- *
- * @param {Signal} signal
- * @param {function} h
- * @returns {boolean}
- */
-function removeHandlerByHandler(signal, h) {
-    const handlers = signal.handlers;
-    let i = findSignalHandlerIndexByHandle(handlers, h);
-
-    if (i >= 0) {
-        handlers.splice(i, 1);
-        return true;
-    }
-
-    return false;
-}
-
-/**
- *
- * @param {Signal} signal
- * @param {function} h
- * @param {*} ctx
- * @returns {boolean}
- */
-function removeHandlerByHandlerAndContext(signal, h, ctx) {
-    const handlers = signal.handlers;
-    const i = findSignalHandlerIndexByHandleAndContext(handlers, h, ctx);
-
-    if (i >= 0) {
-        handlers.splice(i, 1);
-        return true;
-    }
-
-    return false;
-}
-
-
 export default Signal;