@next2d/events 1.18.12 → 2.0.0

package/src/EventDispatcher/service/EventDispatcherAddEventListenerService.js

@@ -0,0 +1,87 @@
+import { Event } from "../../Event";
+import { KeyboardEvent } from "../../KeyboardEvent";
+import { $broadcastEvents, $getArray } from "../../EventUtil";
+/**
+ * @description 指定イベントに関数を登録、既に登録されている場合は上書。
+ *              Register a function in the specified event, or overwrite if already registered.
+ *
+ * @param {EventDispatcher} scope
+ * @param {string} type
+ * @param {Function} listener
+ * @param {boolean} [use_capture = false]
+ * @param {number} [priority = 0]
+ * @method
+ * @protected
+ */
+export const execute = (scope, type, listener, use_capture = false, priority = 0) => {
+    let listenerObjects;
+    switch (type) {
+        // broadcast event
+        case Event.ENTER_FRAME:
+        case KeyboardEvent.KEY_DOWN:
+        case KeyboardEvent.KEY_UP:
+            if (!$broadcastEvents.size
+                || !$broadcastEvents.has(type)) {
+                $broadcastEvents.set(type, $getArray());
+            }
+            listenerObjects = $broadcastEvents.get(type);
+            break;
+        // normal event
+        default:
+            if (!scope._$events) {
+                scope._$events = new Map();
+            }
+            if (!scope._$events.size || !scope._$events.has(type)) {
+                scope._$events.set(type, $getArray());
+            }
+            listenerObjects = scope._$events.get(type);
+            break;
+    }
+    // duplicate check
+    const length = listenerObjects.length;
+    let index = 0;
+    for (; index < length; ++index) {
+        const object = listenerObjects[index];
+        if (use_capture !== object.useCapture) {
+            continue;
+        }
+        if (object.target !== scope) {
+            continue;
+        }
+        if (object.listener !== listener) {
+            continue;
+        }
+        break;
+    }
+    // add or overwrite
+    if (length === index) {
+        // add
+        listenerObjects.push({
+            "listener": listener,
+            "priority": priority,
+            "useCapture": use_capture,
+            "target": scope
+        });
+    }
+    else {
+        // overwrite
+        const object = listenerObjects[index];
+        object.listener = listener;
+        object.priority = priority;
+        object.useCapture = use_capture;
+        object.target = scope;
+    }
+    if (listenerObjects.length > 1) {
+        // sort(DESC)
+        listenerObjects.sort((a, b) => {
+            switch (true) {
+                case a.priority > b.priority:
+                    return -1;
+                case a.priority < b.priority:
+                    return 1;
+                default:
+                    return 0;
+            }
+        });
+    }
+};

package/src/EventDispatcher/service/EventDispatcherDispatchEventService.d.ts

@@ -0,0 +1,13 @@
+import type { EventDispatcher } from "../../EventDispatcher";
+import { Event } from "../../Event";
+/**
+ * @description 指定のイベントを実行します。
+ *              Executes the specified event.
+ *
+ * @param  {EventDispatcher} scope
+ * @param  {Event} event
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends EventDispatcher, E extends Event>(scope: D, event: E) => boolean;

package/src/EventDispatcher/service/EventDispatcherDispatchEventService.js

@@ -0,0 +1,189 @@
+import { Event } from "../../Event";
+import { KeyboardEvent } from "../../KeyboardEvent";
+import { EventPhase } from "../../EventPhase";
+import { $broadcastEvents, $getArray, $poolArray } from "../../EventUtil";
+/**
+ * @description 指定のイベントを実行します。
+ *              Executes the specified event.
+ *
+ * @param  {EventDispatcher} scope
+ * @param  {Event} event
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export const execute = (scope, event) => {
+    switch (event.type) {
+        case Event.ENTER_FRAME:
+        case KeyboardEvent.KEY_DOWN:
+        case KeyboardEvent.KEY_UP:
+            {
+                if (!$broadcastEvents.size
+                    || !$broadcastEvents.has(event.type)) {
+                    return false;
+                }
+                const listenerObjects = $broadcastEvents.get(event.type);
+                if (!listenerObjects.length) {
+                    return false;
+                }
+                for (let idx = 0; idx < listenerObjects.length; ++idx) {
+                    const object = listenerObjects[idx];
+                    // start target
+                    event.eventPhase = EventPhase.AT_TARGET;
+                    // event execute
+                    event.target = event.currentTarget = object.target;
+                    try {
+                        event.listener = object.listener;
+                        object.listener(event);
+                    }
+                    catch (e) {
+                        console.error(e);
+                        return false;
+                    }
+                }
+            }
+            return true;
+        default:
+            {
+                event.target = scope;
+                let currentEvents = null;
+                if (scope._$events
+                    && scope._$events.size
+                    && scope._$events.has(event.type)) {
+                    const events = scope._$events.get(event.type);
+                    if (events) {
+                        currentEvents = events.slice(0);
+                    }
+                }
+                // parent
+                const parentEvents = $getArray();
+                if ("parent" in scope) {
+                    let parent = scope.parent;
+                    while (parent) {
+                        if (parent.hasEventListener(event.type)) {
+                            const events = parent._$events && parent._$events.has(event.type)
+                                ? parent._$events.get(event.type)
+                                : null;
+                            if (events) {
+                                parentEvents.push(events);
+                            }
+                        }
+                        if (!("parent" in parent)) {
+                            break;
+                        }
+                        parent = parent.parent;
+                    }
+                }
+                if (!currentEvents && !parentEvents.length) {
+                    if (currentEvents) {
+                        $poolArray(currentEvents);
+                    }
+                    $poolArray(parentEvents);
+                    return false;
+                }
+                // stage => child... end
+                if (parentEvents.length) {
+                    // start capture
+                    event.eventPhase = EventPhase.CAPTURING_PHASE;
+                    switch (true) {
+                        case event._$stopImmediatePropagation:
+                        case event._$stopPropagation:
+                            break;
+                        default:
+                            for (let idx = parentEvents.length - 1; idx > -1; --idx) {
+                                const events = parentEvents[idx];
+                                for (let idx = 0; idx < events.length; ++idx) {
+                                    const object = events[idx];
+                                    if (!object.useCapture) {
+                                        continue;
+                                    }
+                                    // event execute
+                                    event.currentTarget = object.target;
+                                    try {
+                                        event.listener = object.listener;
+                                        object.listener.call(null, event);
+                                    }
+                                    catch (e) {
+                                        console.error(e);
+                                        return false;
+                                    }
+                                    if (event._$stopImmediatePropagation) {
+                                        break;
+                                    }
+                                }
+                                if (event._$stopImmediatePropagation) {
+                                    break;
+                                }
+                            }
+                            break;
+                    }
+                }
+                if (currentEvents
+                    && !event._$stopImmediatePropagation
+                    && !event._$stopPropagation) {
+                    // start target
+                    event.eventPhase = EventPhase.AT_TARGET;
+                    for (let idx = 0; idx < currentEvents.length; ++idx) {
+                        const object = currentEvents[idx];
+                        if (object.useCapture) {
+                            continue;
+                        }
+                        // event execute
+                        event.currentTarget = object.target;
+                        try {
+                            event.listener = object.listener;
+                            object.listener.call(null, event);
+                        }
+                        catch (e) {
+                            console.error(e);
+                            return false;
+                        }
+                        if (event._$stopImmediatePropagation) {
+                            break;
+                        }
+                    }
+                    $poolArray(currentEvents);
+                }
+                if (parentEvents.length) {
+                    // start bubbling
+                    event.eventPhase = EventPhase.BUBBLING_PHASE;
+                    switch (true) {
+                        case event._$stopImmediatePropagation:
+                        case event._$stopPropagation:
+                        case !event.bubbles:
+                            break;
+                        default:
+                            // this => parent... => stage end
+                            for (let idx = 0; idx < parentEvents.length; ++idx) {
+                                const events = parentEvents[idx];
+                                for (let idx = 0; idx < events.length; ++idx) {
+                                    const object = events[idx];
+                                    if (object.useCapture) {
+                                        continue;
+                                    }
+                                    // event execute
+                                    event.currentTarget = object.target;
+                                    try {
+                                        event.listener = object.listener;
+                                        object.listener.call(null, event);
+                                    }
+                                    catch (e) {
+                                        console.error(e);
+                                        return false;
+                                    }
+                                    if (event._$stopImmediatePropagation) {
+                                        break;
+                                    }
+                                }
+                                if (event._$stopImmediatePropagation) {
+                                    break;
+                                }
+                            }
+                            break;
+                    }
+                    $poolArray(parentEvents);
+                }
+            }
+            return true;
+    }
+};

package/src/EventDispatcher/service/EventDispatcherHasEventListenerService.d.ts

@@ -0,0 +1,12 @@
+import type { EventDispatcher } from "../../EventDispatcher";
+/**
+ * @description 指定イベントが登録されているかを返却。
+ *              Returns whether the specified event is registered.
+ *
+ * @param  {EventDispatcher} scope
+ * @param  {string} type
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends EventDispatcher>(scope: D, type: string) => boolean;

package/src/EventDispatcher/service/EventDispatcherHasEventListenerService.js

@@ -0,0 +1,25 @@
+import { KeyboardEvent } from "../../KeyboardEvent";
+import { Event } from "../../Event";
+import { $broadcastEvents } from "../../EventUtil";
+/**
+ * @description 指定イベントが登録されているかを返却。
+ *              Returns whether the specified event is registered.
+ *
+ * @param  {EventDispatcher} scope
+ * @param  {string} type
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export const execute = (scope, type) => {
+    switch (type) {
+        case Event.ENTER_FRAME:
+        case KeyboardEvent.KEY_DOWN:
+        case KeyboardEvent.KEY_UP:
+            return $broadcastEvents.size && $broadcastEvents.has(type) ? true : false;
+        default:
+            return !!(scope._$events
+                && scope._$events.size
+                && scope._$events.has(type));
+    }
+};

package/src/EventDispatcher/service/EventDispatcherRemoveAllEventListenerService.d.ts

@@ -0,0 +1,13 @@
+import type { EventDispatcher } from "../../EventDispatcher";
+/**
+ * @description イベントリスナーを全て削除。
+ *              Remove all event listeners.
+ *
+ * @param  {EventDispatcher} scope
+ * @param  {string} type
+ * @param  {boolean} use_capture
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends EventDispatcher>(scope: D, type: string, use_capture?: boolean) => void;

package/src/EventDispatcher/service/EventDispatcherRemoveAllEventListenerService.js

@@ -0,0 +1,83 @@
+import { KeyboardEvent } from "../../KeyboardEvent";
+import { Event } from "../../Event";
+import { $broadcastEvents, $getArray, $poolArray } from "../../EventUtil";
+/**
+ * @description イベントリスナーを全て削除。
+ *              Remove all event listeners.
+ *
+ * @param  {EventDispatcher} scope
+ * @param  {string} type
+ * @param  {boolean} use_capture
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (scope, type, use_capture = false) => {
+    let listenerObjects;
+    switch (type) {
+        case Event.ENTER_FRAME:
+        case KeyboardEvent.KEY_DOWN:
+        case KeyboardEvent.KEY_UP:
+            if (!$broadcastEvents.size
+                || !$broadcastEvents.has(type)) {
+                return;
+            }
+            listenerObjects = $broadcastEvents.get(type);
+            break;
+        default:
+            if (!scope._$events
+                || !scope._$events.size
+                || !scope._$events.has(type)) {
+                return;
+            }
+            listenerObjects = scope._$events.get(type);
+            break;
+    }
+    if (!listenerObjects) {
+        return;
+    }
+    // remove listener
+    const results = $getArray();
+    for (let idx = 0; idx < listenerObjects.length; ++idx) {
+        // event object
+        const object = listenerObjects[idx];
+        if (use_capture === object.useCapture) {
+            continue;
+        }
+        results.push(object);
+    }
+    if (!results.length) {
+        if ($broadcastEvents.has(type)) {
+            $broadcastEvents.delete(type);
+        }
+        if (scope._$events && scope._$events.has(type)) {
+            scope._$events.delete(type);
+            if (!scope._$events.size) {
+                scope._$events = null;
+            }
+        }
+        $poolArray(results);
+        $poolArray(listenerObjects);
+        return;
+    }
+    if (results.length > 1) {
+        // event sort (DESC)
+        results.sort((a, b) => {
+            switch (true) {
+                case a.priority > b.priority:
+                    return -1;
+                case a.priority < b.priority:
+                    return 1;
+                default:
+                    return 0;
+            }
+        });
+    }
+    if ($broadcastEvents.has(type)) {
+        $broadcastEvents.set(type, results);
+    }
+    else {
+        scope._$events?.set(type, results);
+    }
+    $poolArray(listenerObjects);
+};

package/src/EventDispatcher/service/EventDispatcherRemoveEventListenerService.d.ts

@@ -0,0 +1,14 @@
+import type { EventDispatcher } from "../../EventDispatcher";
+/**
+ * @description イベントリスナーを削除。
+ *              Remove the event listener.
+ *
+ * @param  {EventDispatcher} scope
+ * @param  {string} type
+ * @param  {Function} listener
+ * @param  {boolean} [use_capture = false]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends EventDispatcher>(scope: D, type: string, listener: Function, use_capture?: boolean) => void;

package/src/EventDispatcher/service/EventDispatcherRemoveEventListenerService.js

@@ -0,0 +1,80 @@
+import { Event } from "../../Event";
+import { KeyboardEvent } from "../../KeyboardEvent";
+import { $broadcastEvents, $poolArray } from "../../EventUtil";
+/**
+ * @description イベントリスナーを削除。
+ *              Remove the event listener.
+ *
+ * @param  {EventDispatcher} scope
+ * @param  {string} type
+ * @param  {Function} listener
+ * @param  {boolean} [use_capture = false]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (scope, type, listener, use_capture = false) => {
+    let listenerObjects;
+    switch (type) {
+        case Event.ENTER_FRAME:
+        case KeyboardEvent.KEY_DOWN:
+        case KeyboardEvent.KEY_UP:
+            if (!$broadcastEvents.size
+                || !$broadcastEvents.has(type)) {
+                return;
+            }
+            listenerObjects = $broadcastEvents.get(type);
+            break;
+        default:
+            if (!scope._$events
+                || !scope._$events.size
+                || !scope._$events.has(type)) {
+                return;
+            }
+            listenerObjects = scope._$events.get(type);
+            break;
+    }
+    if (!listenerObjects) {
+        return;
+    }
+    // remove listener
+    for (let idx = 0; idx < listenerObjects.length; ++idx) {
+        // event object
+        const object = listenerObjects[idx];
+        if (use_capture !== object.useCapture) {
+            continue;
+        }
+        if (object.listener !== listener) {
+            continue;
+        }
+        // delete if match
+        listenerObjects.splice(idx, 1);
+        break;
+    }
+    if (!listenerObjects.length) {
+        if ($broadcastEvents.has(type)) {
+            $broadcastEvents.delete(type);
+        }
+        if (scope._$events && scope._$events.has(type)) {
+            scope._$events.delete(type);
+            if (!scope._$events.size) {
+                scope._$events = null;
+            }
+        }
+        $poolArray(listenerObjects);
+        return;
+    }
+    if (listenerObjects.length > 1) {
+        // event sort(DESC)
+        listenerObjects.sort((a, b) => {
+            switch (true) {
+                case a.priority > b.priority:
+                    return -1;
+                case a.priority < b.priority:
+                    return 1;
+                default:
+                    return 0;
+            }
+        });
+    }
+};

package/src/EventDispatcher/service/EventDispatcherWillTriggerService.d.ts

@@ -0,0 +1,12 @@
+import type { EventDispatcher } from "../../EventDispatcher";
+/**
+ * @description 先祖も含めてイベントリスナーが登録されているかどうかを判定。
+ *              Determine whether an event listener is registered, including ancestors.
+ *
+ * @param  {EventDispatcher} scope
+ * @param  {string} type
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends EventDispatcher>(scope: D, type: string) => boolean;

package/src/EventDispatcher/service/EventDispatcherWillTriggerService.js

@@ -0,0 +1,28 @@
+/**
+ * @description 先祖も含めてイベントリスナーが登録されているかどうかを判定。
+ *              Determine whether an event listener is registered, including ancestors.
+ *
+ * @param  {EventDispatcher} scope
+ * @param  {string} type
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export const execute = (scope, type) => {
+    if (scope.hasEventListener(type)) {
+        return true;
+    }
+    if ("parent" in scope) {
+        let parent = scope.parent;
+        while (parent) {
+            if (parent.hasEventListener(type)) {
+                return true;
+            }
+            if (!("parent" in parent)) {
+                break;
+            }
+            parent = parent.parent;
+        }
+    }
+    return false;
+};