angular-three 0.0.2 → 0.0.4

package/esm2020/lib/utils/events.mjs

@@ -0,0 +1,353 @@
+import * as THREE from 'three';
+import { getInstanceLocalState } from './get-instance-local-state';
+import { makeId } from './make';
+/**
+ * Release pointer captures.
+ * This is called by releasePointerCapture in the API, and when an object is removed.
+ */
+function releaseInternalPointerCapture(capturedMap, obj, captures, pointerId) {
+    const captureData = captures.get(obj);
+    if (captureData) {
+        captures.delete(obj);
+        // If this was the last capturing object for this pointer
+        if (captures.size === 0) {
+            capturedMap.delete(pointerId);
+            captureData.target.releasePointerCapture(pointerId);
+        }
+    }
+}
+export function removeInteractivity(stateFactory, object) {
+    const { internal } = stateFactory();
+    // Removes every trace of an object from the data store
+    internal.interaction = internal.interaction.filter((o) => o !== object);
+    internal.initialHits = internal.initialHits.filter((o) => o !== object);
+    internal.hovered.forEach((value, key) => {
+        if (value.eventObject === object || value.object === object) {
+            // Clear out intersects, they are outdated by now
+            internal.hovered.delete(key);
+        }
+    });
+    internal.capturedMap.forEach((captures, pointerId) => {
+        releaseInternalPointerCapture(internal.capturedMap, object, captures, pointerId);
+    });
+}
+export function createEvents(stateFactory) {
+    /** Calculates delta */
+    function calculateDistance(event) {
+        const { internal } = stateFactory();
+        const dx = event.offsetX - internal.initialClick[0];
+        const dy = event.offsetY - internal.initialClick[1];
+        return Math.round(Math.sqrt(dx * dx + dy * dy));
+    }
+    /** Returns true if an instance has a valid pointer-event registered, this excludes scroll, clicks etc */
+    function filterPointerEvents(objects) {
+        return objects.filter((obj) => ['move', 'over', 'enter', 'out', 'leave'].some((name) => {
+            const eventName = ('pointer' + name);
+            return getInstanceLocalState(obj)?.handlers[eventName];
+        }));
+    }
+    function intersect(event, filter) {
+        const state = stateFactory();
+        const duplicates = new Set();
+        const intersections = [];
+        // Allow callers to eliminate event objects
+        const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction;
+        // Reset all raycaster cameras to undefined
+        for (let i = 0; i < eventsObjects.length; i++) {
+            const instanceState = getInstanceLocalState(eventsObjects[i])?.stateFactory();
+            if (instanceState) {
+                instanceState.raycaster.camera = undefined;
+            }
+        }
+        if (!state.previousStateFactory) {
+            // Make sure root-level pointer and ray are set up
+            state.events.compute?.(event, () => state);
+        }
+        function handleRaycast(obj) {
+            const state = getInstanceLocalState(obj)?.stateFactory();
+            // Skip event handling when noEvents is set, or when the raycasters camera is null
+            if (!state || !state.events.enabled || state.raycaster.camera === null)
+                return [];
+            // When the camera is undefined we have to call the event layers update function
+            if (state.raycaster.camera === undefined) {
+                state.events.compute?.(event, () => state, state.previousStateFactory);
+                // If the camera is still undefined we have to skip this layer entirely
+                if (state.raycaster.camera === undefined)
+                    state.raycaster.camera = null;
+            }
+            // Intersect object by object
+            return state.raycaster.camera ? state.raycaster.intersectObject(obj, true) : [];
+        }
+        // Collect events
+        let hits = eventsObjects
+            // Intersect objects
+            .flatMap(handleRaycast)
+            // Sort by event priority and distance
+            .sort((a, b) => {
+            const aState = getInstanceLocalState(a.object)?.stateFactory();
+            const bState = getInstanceLocalState(b.object)?.stateFactory();
+            if (!aState || !bState)
+                return 0;
+            return bState.events.priority - aState.events.priority || a.distance - b.distance;
+        })
+            // Filter out duplicates
+            .filter((item) => {
+            const id = makeId(item);
+            if (duplicates.has(id))
+                return false;
+            duplicates.add(id);
+            return true;
+        });
+        // https://github.com/mrdoob/three.js/issues/16031
+        // Allow custom userland intersect sort order, this likely only makes sense on the root filter
+        if (state.events.filter)
+            hits = state.events.filter(hits, () => state);
+        // Bubble up the events, find the event source (eventObject)
+        for (const hit of hits) {
+            let eventObject = hit.object;
+            // Bubble event up
+            while (eventObject) {
+                if (getInstanceLocalState(eventObject)?.eventCount)
+                    intersections.push({ ...hit, eventObject });
+                eventObject = eventObject.parent;
+            }
+        }
+        // If the interaction is captured, make all capturing targets part of the intersect.
+        if ('pointerId' in event && state.internal.capturedMap.has(event.pointerId)) {
+            for (const captureData of state.internal.capturedMap.get(event.pointerId).values()) {
+                intersections.push(captureData.intersection);
+            }
+        }
+        return intersections;
+    }
+    /**  Handles intersections by forwarding them to handlers */
+    function handleIntersects(intersections, event, delta, callback) {
+        const rootState = stateFactory();
+        // If anything has been found, forward it to the event listeners
+        if (intersections.length) {
+            const localState = { stopped: false };
+            for (const hit of intersections) {
+                const state = getInstanceLocalState(hit.object)?.stateFactory() || rootState;
+                const { raycaster, pointer, camera, internal } = state;
+                const unprojectedPoint = new THREE.Vector3(pointer.x, pointer.y, 0).unproject(camera);
+                const hasPointerCapture = (id) => internal.capturedMap.get(id)?.has(hit.eventObject) ?? false;
+                const setPointerCapture = (id) => {
+                    const captureData = {
+                        intersection: hit,
+                        target: event.target,
+                    };
+                    if (internal.capturedMap.has(id)) {
+                        // if the pointerId was previously captured, we add the hit to the
+                        // event capturedMap.
+                        internal.capturedMap.get(id).set(hit.eventObject, captureData);
+                    }
+                    else {
+                        // if the pointerId was not previously captured, we create a map
+                        // containing the hitObject, and the hit. hitObject is used for
+                        // faster access.
+                        internal.capturedMap.set(id, new Map([[hit.eventObject, captureData]]));
+                    }
+                    // Call the original event now
+                    event.target.setPointerCapture(id);
+                };
+                const releasePointerCapture = (id) => {
+                    const captures = internal.capturedMap.get(id);
+                    if (captures) {
+                        releaseInternalPointerCapture(internal.capturedMap, hit.eventObject, captures, id);
+                    }
+                };
+                // Add native event props
+                const extractEventProps = {};
+                // This iterates over the event's properties including the inherited ones. Native PointerEvents have most of their props as getters which are inherited, but polyfilled PointerEvents have them all as their own properties (i.e. not inherited). We can't use Object.keys() or Object.entries() as they only return "own" properties; nor Object.getPrototypeOf(event) as that *doesn't* return "own" properties, only inherited ones.
+                for (const prop in event) {
+                    const property = event[prop];
+                    // Only copy over atomics, leave functions alone as these should be
+                    // called as event.nativeEvent.fn()
+                    if (typeof property !== 'function')
+                        extractEventProps[prop] = property;
+                }
+                const raycastEvent = {
+                    ...hit,
+                    ...extractEventProps,
+                    pointer,
+                    intersections,
+                    stopped: localState.stopped,
+                    delta,
+                    unprojectedPoint,
+                    ray: raycaster.ray,
+                    camera: camera,
+                    // Hijack stopPropagation, which just sets a flag
+                    stopPropagation() {
+                        // https://github.com/pmndrs/react-three-fiber/issues/596
+                        // Events are not allowed to stop propagation if the pointer has been captured
+                        const capturesForPointer = 'pointerId' in event && internal.capturedMap.get(event.pointerId);
+                        // We only authorize stopPropagation...
+                        if (
+                        // ...if this pointer hasn't been captured
+                        !capturesForPointer ||
+                            // ... or if the hit object is capturing the pointer
+                            capturesForPointer.has(hit.eventObject)) {
+                            raycastEvent.stopped = localState.stopped = true;
+                            // Propagation is stopped, remove all other hover records
+                            // An event handler is only allowed to flush other handlers if it is hovered itself
+                            if (internal.hovered.size &&
+                                Array.from(internal.hovered.values()).find((i) => i.eventObject === hit.eventObject)) {
+                                // Objects cannot flush out higher up objects that have already caught the event
+                                const higher = intersections.slice(0, intersections.indexOf(hit));
+                                cancelPointer([...higher, hit]);
+                            }
+                        }
+                    },
+                    // there should be a distinction between target and currentTarget
+                    target: {
+                        hasPointerCapture,
+                        setPointerCapture,
+                        releasePointerCapture,
+                    },
+                    currentTarget: {
+                        hasPointerCapture,
+                        setPointerCapture,
+                        releasePointerCapture,
+                    },
+                    nativeEvent: event,
+                };
+                // Call subscribers
+                callback(raycastEvent);
+                // Event bubbling may be interrupted by stopPropagation
+                if (localState.stopped === true)
+                    break;
+            }
+        }
+        return intersections;
+    }
+    function cancelPointer(intersections) {
+        const { internal } = stateFactory();
+        for (const hoveredObj of internal.hovered.values()) {
+            // When no objects were hit or the hovered object wasn't found underneath the cursor
+            // we call onPointerOut and delete the object from the hovered-elements map
+            if (!intersections.length ||
+                !intersections.find((hit) => hit.object === hoveredObj.object &&
+                    hit.index === hoveredObj.index &&
+                    hit.instanceId === hoveredObj.instanceId)) {
+                const eventObject = hoveredObj.eventObject;
+                const instance = getInstanceLocalState(eventObject);
+                const handlers = instance?.handlers;
+                internal.hovered.delete(makeId(hoveredObj));
+                if (instance?.eventCount) {
+                    // Clear out intersects, they are outdated by now
+                    const data = { ...hoveredObj, intersections };
+                    handlers?.pointerout?.(data);
+                    handlers?.pointerleave?.(data);
+                }
+            }
+        }
+    }
+    function pointerMissed(event, objects) {
+        for (let i = 0; i < objects.length; i++) {
+            const instance = getInstanceLocalState(objects[i]);
+            instance?.handlers.pointermissed?.(event);
+        }
+    }
+    function handlePointer(name) {
+        // Deal with cancelation
+        switch (name) {
+            case 'pointerleave':
+            case 'pointercancel':
+                return () => cancelPointer([]);
+            case 'lostpointercapture':
+                return (event) => {
+                    const { internal } = stateFactory();
+                    if ('pointerId' in event && !internal.capturedMap.has(event.pointerId)) {
+                        // If the object event interface had onLostPointerCapture, we'd call it here on every
+                        // object that's getting removed.
+                        internal.capturedMap.delete(event.pointerId);
+                        cancelPointer([]);
+                    }
+                };
+        }
+        // Any other pointer goes here ...
+        return function handleEvent(event) {
+            const { onPointerMissed, internal } = stateFactory();
+            // prepareRay(event)
+            internal.lastEvent = event;
+            // Get fresh intersects
+            const isPointerMove = name === 'pointermove';
+            const isClickEvent = name === 'click' || name === 'contextmenu' || name === 'dblclick';
+            const filter = isPointerMove ? filterPointerEvents : undefined;
+            // const hits = patchIntersects(intersect(filter), event)
+            const hits = intersect(event, filter);
+            const delta = isClickEvent ? calculateDistance(event) : 0;
+            // Save initial coordinates on pointer-down
+            if (name === 'pointerdown') {
+                internal.initialClick = [event.offsetX, event.offsetY];
+                internal.initialHits = hits.map((hit) => hit.eventObject);
+            }
+            // If a click yields no results, pass it back to the user as a miss
+            // Missed events have to come first in order to establish user-land side-effect clean up
+            if (isClickEvent && !hits.length) {
+                if (delta <= 2) {
+                    pointerMissed(event, internal.interaction);
+                    if (onPointerMissed)
+                        onPointerMissed(event);
+                }
+            }
+            // Take care of unhover
+            if (isPointerMove)
+                cancelPointer(hits);
+            function onIntersect(data) {
+                const eventObject = data.eventObject;
+                const instance = getInstanceLocalState(eventObject);
+                const handlers = instance?.handlers;
+                // Check presence of handlers
+                if (!instance?.eventCount)
+                    return;
+                if (isPointerMove) {
+                    // Move event ...
+                    if (handlers?.pointerover ||
+                        handlers?.pointerenter ||
+                        handlers?.pointerout ||
+                        handlers?.pointerleave) {
+                        // When enter or out is present take care of hover-state
+                        const id = makeId(data);
+                        const hoveredItem = internal.hovered.get(id);
+                        if (!hoveredItem) {
+                            // If the object wasn't previously hovered, book it and call its handler
+                            internal.hovered.set(id, data);
+                            handlers.pointerover?.(data);
+                            handlers.pointerenter?.(data);
+                        }
+                        else if (hoveredItem.stopped) {
+                            // If the object was previously hovered and stopped, we shouldn't allow other items to proceed
+                            data.stopPropagation();
+                        }
+                    }
+                    // Call mouse move
+                    handlers?.pointermove?.(data);
+                }
+                else {
+                    // All other events ...
+                    const handler = handlers[name];
+                    if (handler) {
+                        // Forward all events back to their respective handlers with the exception of click events,
+                        // which must use the initial target
+                        if (!isClickEvent || internal.initialHits.includes(eventObject)) {
+                            // Missed events have to come first
+                            pointerMissed(event, internal.interaction.filter((object) => !internal.initialHits.includes(object)));
+                            // Now call the handler
+                            handler(data);
+                        }
+                    }
+                    else {
+                        // Trigger onPointerMissed on all elements that have pointer over/out handlers, but not click and weren't hit
+                        if (isClickEvent && internal.initialHits.includes(eventObject)) {
+                            pointerMissed(event, internal.interaction.filter((object) => !internal.initialHits.includes(object)));
+                        }
+                    }
+                }
+            }
+            handleIntersects(hits, event, delta, onIntersect);
+        };
+    }
+    return { handlePointer };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"events.js","sourceRoot":"","sources":["../../../../../../packages/angular-three/src/lib/utils/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAS/B,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;GAGG;AACH,SAAS,6BAA6B,CAClC,WAAsE,EACtE,GAAmB,EACnB,QAAsD,EACtD,SAAiB;IAEjB,MAAM,WAAW,GAAwC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC3E,IAAI,WAAW,EAAE;QACb,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACrB,yDAAyD;QACzD,IAAI,QAAQ,CAAC,IAAI,KAAK,CAAC,EAAE;YACrB,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YAC9B,WAAW,CAAC,MAAM,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC;SACvD;KACJ;AACL,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,YAA6B,EAAE,MAAsB;IACrF,MAAM,EAAE,QAAQ,EAAE,GAAG,YAAY,EAAE,CAAC;IACpC,uDAAuD;IACvD,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC;IACxE,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC;IACxE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;QACpC,IAAI,KAAK,CAAC,WAAW,KAAK,MAAM,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM,EAAE;YACzD,iDAAiD;YACjD,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;SAChC;IACL,CAAC,CAAC,CAAC;IACH,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,SAAS,EAAE,EAAE;QACjD,6BAA6B,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IACrF,CAAC,CAAC,CAAC;AACP,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,YAA6B;IACtD,uBAAuB;IACvB,SAAS,iBAAiB,CAAC,KAAkB;QACzC,MAAM,EAAE,QAAQ,EAAE,GAAG,YAAY,EAAE,CAAC;QACpC,MAAM,EAAE,GAAG,KAAK,CAAC,OAAO,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACpD,MAAM,EAAE,GAAG,KAAK,CAAC,OAAO,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;IACpD,CAAC;IAED,yGAAyG;IACzG,SAAS,mBAAmB,CAAC,OAAyB;QAClD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAC1B,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;YACpD,MAAM,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAA2B,CAAC;YAC/D,OAAO,qBAAqB,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;QAC3D,CAAC,CAAC,CACL,CAAC;IACN,CAAC;IAED,SAAS,SAAS,CAAC,KAAkB,EAAE,MAAwD;QAC3F,MAAM,KAAK,GAAG,YAAY,EAAE,CAAC;QAC7B,MAAM,UAAU,GAAG,IAAI,GAAG,EAAU,CAAC;QACrC,MAAM,aAAa,GAAsB,EAAE,CAAC;QAC5C,2CAA2C;QAC3C,MAAM,aAAa,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC;QAC/F,2CAA2C;QAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC3C,MAAM,aAAa,GAAG,qBAAqB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC;YAC9E,IAAI,aAAa,EAAE;gBACf,aAAa,CAAC,SAAS,CAAC,MAAM,GAAG,SAAU,CAAC;aAC/C;SACJ;QAED,IAAI,CAAC,KAAK,CAAC,oBAAoB,EAAE;YAC7B,kDAAkD;YAClD,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;SAC9C;QAED,SAAS,aAAa,CAAC,GAAgC;YACnD,MAAM,KAAK,GAAG,qBAAqB,CAAC,GAAG,CAAC,EAAE,YAAY,EAAE,CAAC;YACzD,kFAAkF;YAClF,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,KAAK,IAAI;gBAAE,OAAO,EAAE,CAAC;YAElF,gFAAgF;YAChF,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,KAAK,SAAS,EAAE;gBACtC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC;gBACvE,uEAAuE;gBACvE,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,KAAK,SAAS;oBAAE,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,IAAK,CAAC;aAC5E;YAED,6BAA6B;YAC7B,OAAO,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,eAAe,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACpF,CAAC;QAED,iBAAiB;QACjB,IAAI,IAAI,GAAsD,aAAa;YACvE,oBAAoB;aACnB,OAAO,CAAC,aAAa,CAAC;YACvB,sCAAsC;aACrC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;YACX,MAAM,MAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;YAC/D,MAAM,MAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;YAC/D,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM;gBAAE,OAAO,CAAC,CAAC;YACjC,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC;QACtF,CAAC,CAAC;YACF,wBAAwB;aACvB,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;YACb,MAAM,EAAE,GAAG,MAAM,CAAC,IAAuB,CAAC,CAAC;YAC3C,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBAAE,OAAO,KAAK,CAAC;YACrC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACnB,OAAO,IAAI,CAAC;QAChB,CAAC,CAAC,CAAC;QAEP,kDAAkD;QAClD,8FAA8F;QAC9F,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM;YAAE,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;QAEvE,4DAA4D;QAC5D,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACpB,IAAI,WAAW,GAA0B,GAAG,CAAC,MAAM,CAAC;YACpD,kBAAkB;YAClB,OAAO,WAAW,EAAE;gBAChB,IAAI,qBAAqB,CAAC,WAAW,CAAC,EAAE,UAAU;oBAAE,aAAa,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC;gBAChG,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC;aACpC;SACJ;QAED,oFAAoF;QACpF,IAAI,WAAW,IAAI,KAAK,IAAI,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE;YACzE,KAAK,MAAM,WAAW,IAAI,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAE,CAAC,MAAM,EAAE,EAAE;gBACjF,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;aAChD;SACJ;QACD,OAAO,aAAa,CAAC;IACzB,CAAC;IAED,4DAA4D;IAC5D,SAAS,gBAAgB,CACrB,aAAgC,EAChC,KAAkB,EAClB,KAAa,EACb,QAAqD;QAErD,MAAM,SAAS,GAAG,YAAY,EAAE,CAAC;QACjC,gEAAgE;QAChE,IAAI,aAAa,CAAC,MAAM,EAAE;YACtB,MAAM,UAAU,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;YACtC,KAAK,MAAM,GAAG,IAAI,aAAa,EAAE;gBAC7B,MAAM,KAAK,GAAG,qBAAqB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,YAAY,EAAE,IAAI,SAAS,CAAC;gBAC7E,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;gBACvD,MAAM,gBAAgB,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;gBACtF,MAAM,iBAAiB,GAAG,CAAC,EAAU,EAAE,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,KAAK,CAAC;gBAEtG,MAAM,iBAAiB,GAAG,CAAC,EAAU,EAAE,EAAE;oBACrC,MAAM,WAAW,GAAG;wBAChB,YAAY,EAAE,GAAG;wBACjB,MAAM,EAAE,KAAK,CAAC,MAAiB;qBAClC,CAAC;oBACF,IAAI,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;wBAC9B,kEAAkE;wBAClE,qBAAqB;wBACrB,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAE,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;qBACnE;yBAAM;wBACH,gEAAgE;wBAChE,+DAA+D;wBAC/D,iBAAiB;wBACjB,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;qBAC3E;oBACD,8BAA8B;oBAC7B,KAAK,CAAC,MAAkB,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;gBACpD,CAAC,CAAC;gBAEF,MAAM,qBAAqB,GAAG,CAAC,EAAU,EAAE,EAAE;oBACzC,MAAM,QAAQ,GAAG,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBAC9C,IAAI,QAAQ,EAAE;wBACV,6BAA6B,CAAC,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,WAAW,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;qBACtF;gBACL,CAAC,CAAC;gBAEF,yBAAyB;gBACzB,MAAM,iBAAiB,GAAQ,EAAE,CAAC;gBAClC,uaAAua;gBACva,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;oBACtB,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAyB,CAAC,CAAC;oBAClD,mEAAmE;oBACnE,mCAAmC;oBACnC,IAAI,OAAO,QAAQ,KAAK,UAAU;wBAAE,iBAAiB,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC;iBAC1E;gBAED,MAAM,YAAY,GAA+B;oBAC7C,GAAG,GAAG;oBACN,GAAG,iBAAiB;oBACpB,OAAO;oBACP,aAAa;oBACb,OAAO,EAAE,UAAU,CAAC,OAAO;oBAC3B,KAAK;oBACL,gBAAgB;oBAChB,GAAG,EAAE,SAAS,CAAC,GAAG;oBAClB,MAAM,EAAE,MAAM;oBACd,iDAAiD;oBACjD,eAAe;wBACX,yDAAyD;wBACzD,8EAA8E;wBAC9E,MAAM,kBAAkB,GAAG,WAAW,IAAI,KAAK,IAAI,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;wBAE7F,uCAAuC;wBACvC;wBACI,0CAA0C;wBAC1C,CAAC,kBAAkB;4BACnB,oDAAoD;4BACpD,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,CAAC,EACzC;4BACE,YAAY,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,GAAG,IAAI,CAAC;4BACjD,yDAAyD;4BACzD,mFAAmF;4BACnF,IACI,QAAQ,CAAC,OAAO,CAAC,IAAI;gCACrB,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,GAAG,CAAC,WAAW,CAAC,EACtF;gCACE,gFAAgF;gCAChF,MAAM,MAAM,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;gCAClE,aAAa,CAAC,CAAC,GAAG,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;6BACnC;yBACJ;oBACL,CAAC;oBACD,iEAAiE;oBACjE,MAAM,EAAE;wBACJ,iBAAiB;wBACjB,iBAAiB;wBACjB,qBAAqB;qBACxB;oBACD,aAAa,EAAE;wBACX,iBAAiB;wBACjB,iBAAiB;wBACjB,qBAAqB;qBACxB;oBACD,WAAW,EAAE,KAAK;iBACrB,CAAC;gBAEF,mBAAmB;gBACnB,QAAQ,CAAC,YAAY,CAAC,CAAC;gBACvB,uDAAuD;gBACvD,IAAI,UAAU,CAAC,OAAO,KAAK,IAAI;oBAAE,MAAM;aAC1C;SACJ;QACD,OAAO,aAAa,CAAC;IACzB,CAAC;IAED,SAAS,aAAa,CAAC,aAAgC;QACnD,MAAM,EAAE,QAAQ,EAAE,GAAG,YAAY,EAAE,CAAC;QACpC,KAAK,MAAM,UAAU,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE;YAChD,oFAAoF;YACpF,2EAA2E;YAC3E,IACI,CAAC,aAAa,CAAC,MAAM;gBACrB,CAAC,aAAa,CAAC,IAAI,CACf,CAAC,GAAG,EAAE,EAAE,CACJ,GAAG,CAAC,MAAM,KAAK,UAAU,CAAC,MAAM;oBAChC,GAAG,CAAC,KAAK,KAAK,UAAU,CAAC,KAAK;oBAC9B,GAAG,CAAC,UAAU,KAAK,UAAU,CAAC,UAAU,CAC/C,EACH;gBACE,MAAM,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;gBAC3C,MAAM,QAAQ,GAAG,qBAAqB,CAAC,WAAW,CAAC,CAAC;gBACpD,MAAM,QAAQ,GAAG,QAAQ,EAAE,QAAQ,CAAC;gBACpC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;gBAC5C,IAAI,QAAQ,EAAE,UAAU,EAAE;oBACtB,iDAAiD;oBACjD,MAAM,IAAI,GAAG,EAAE,GAAG,UAAU,EAAE,aAAa,EAAE,CAAC;oBAC9C,QAAQ,EAAE,UAAU,EAAE,CAAC,IAAmC,CAAC,CAAC;oBAC5D,QAAQ,EAAE,YAAY,EAAE,CAAC,IAAmC,CAAC,CAAC;iBACjE;aACJ;SACJ;IACL,CAAC;IAED,SAAS,aAAa,CAAC,KAAiB,EAAE,OAAyB;QAC/D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACrC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;YACnD,QAAQ,EAAE,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,CAAC;SAC7C;IACL,CAAC;IAED,SAAS,aAAa,CAAC,IAAY;QAC/B,wBAAwB;QACxB,QAAQ,IAAI,EAAE;YACV,KAAK,cAAc,CAAC;YACpB,KAAK,eAAe;gBAChB,OAAO,GAAG,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;YACnC,KAAK,oBAAoB;gBACrB,OAAO,CAAC,KAAkB,EAAE,EAAE;oBAC1B,MAAM,EAAE,QAAQ,EAAE,GAAG,YAAY,EAAE,CAAC;oBACpC,IAAI,WAAW,IAAI,KAAK,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE;wBACpE,qFAAqF;wBACrF,iCAAiC;wBACjC,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;wBAC7C,aAAa,CAAC,EAAE,CAAC,CAAC;qBACrB;gBACL,CAAC,CAAC;SACT;QAED,kCAAkC;QAClC,OAAO,SAAS,WAAW,CAAC,KAAkB;YAC1C,MAAM,EAAE,eAAe,EAAE,QAAQ,EAAE,GAAG,YAAY,EAAE,CAAC;YAErD,oBAAoB;YACpB,QAAQ,CAAC,SAAS,GAAG,KAAK,CAAC;YAE3B,uBAAuB;YACvB,MAAM,aAAa,GAAG,IAAI,KAAK,aAAa,CAAC;YAC7C,MAAM,YAAY,GAAG,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,aAAa,IAAI,IAAI,KAAK,UAAU,CAAC;YACvF,MAAM,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,SAAS,CAAC;YAC/D,yDAAyD;YACzD,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YACtC,MAAM,KAAK,GAAG,YAAY,CAAC,CAAC,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAE1D,2CAA2C;YAC3C,IAAI,IAAI,KAAK,aAAa,EAAE;gBACxB,QAAQ,CAAC,YAAY,GAAG,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;gBACvD,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;aAC7D;YAED,mEAAmE;YACnE,wFAAwF;YACxF,IAAI,YAAY,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;gBAC9B,IAAI,KAAK,IAAI,CAAC,EAAE;oBACZ,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;oBAC3C,IAAI,eAAe;wBAAE,eAAe,CAAC,KAAK,CAAC,CAAC;iBAC/C;aACJ;YACD,uBAAuB;YACvB,IAAI,aAAa;gBAAE,aAAa,CAAC,IAAI,CAAC,CAAC;YAEvC,SAAS,WAAW,CAAC,IAAgC;gBACjD,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;gBACrC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,WAAW,CAAC,CAAC;gBACpD,MAAM,QAAQ,GAAG,QAAQ,EAAE,QAAQ,CAAC;gBACpC,6BAA6B;gBAC7B,IAAI,CAAC,QAAQ,EAAE,UAAU;oBAAE,OAAO;gBAElC,IAAI,aAAa,EAAE;oBACf,iBAAiB;oBACjB,IACI,QAAQ,EAAE,WAAW;wBACrB,QAAQ,EAAE,YAAY;wBACtB,QAAQ,EAAE,UAAU;wBACpB,QAAQ,EAAE,YAAY,EACxB;wBACE,wDAAwD;wBACxD,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;wBACxB,MAAM,WAAW,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;wBAC7C,IAAI,CAAC,WAAW,EAAE;4BACd,wEAAwE;4BACxE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;4BAC/B,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAmC,CAAC,CAAC;4BAC5D,QAAQ,CAAC,YAAY,EAAE,CAAC,IAAmC,CAAC,CAAC;yBAChE;6BAAM,IAAI,WAAW,CAAC,OAAO,EAAE;4BAC5B,8FAA8F;4BAC9F,IAAI,CAAC,eAAe,EAAE,CAAC;yBAC1B;qBACJ;oBACD,kBAAkB;oBAClB,QAAQ,EAAE,WAAW,EAAE,CAAC,IAAmC,CAAC,CAAC;iBAChE;qBAAM;oBACH,uBAAuB;oBACvB,MAAM,OAAO,GAAG,QAAS,CAAC,IAA8B,CAE/C,CAAC;oBACV,IAAI,OAAO,EAAE;wBACT,2FAA2F;wBAC3F,oCAAoC;wBACpC,IAAI,CAAC,YAAY,IAAI,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;4BAC7D,mCAAmC;4BACnC,aAAa,CACT,KAAK,EACL,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAClF,CAAC;4BACF,uBAAuB;4BACvB,OAAO,CAAC,IAAmC,CAAC,CAAC;yBAChD;qBACJ;yBAAM;wBACH,6GAA6G;wBAC7G,IAAI,YAAY,IAAI,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;4BAC5D,aAAa,CACT,KAAK,EACL,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAClF,CAAC;yBACL;qBACJ;iBACJ;YACL,CAAC;YAED,gBAAgB,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC;QACtD,CAAC,CAAC;IACN,CAAC;IAED,OAAO,EAAE,aAAa,EAAE,CAAC;AAC7B,CAAC","sourcesContent":["import * as THREE from 'three';\nimport type {\n    NgtDomEvent,\n    NgtEventHandlers,\n    NgtIntersection,\n    NgtPointerCaptureTarget,\n    NgtStateFactory,\n    NgtThreeEvent,\n} from '../types';\nimport { getInstanceLocalState } from './get-instance-local-state';\nimport { makeId } from './make';\n\n/**\n * Release pointer captures.\n * This is called by releasePointerCapture in the API, and when an object is removed.\n */\nfunction releaseInternalPointerCapture(\n    capturedMap: Map<number, Map<THREE.Object3D, NgtPointerCaptureTarget>>,\n    obj: THREE.Object3D,\n    captures: Map<THREE.Object3D, NgtPointerCaptureTarget>,\n    pointerId: number\n): void {\n    const captureData: NgtPointerCaptureTarget | undefined = captures.get(obj);\n    if (captureData) {\n        captures.delete(obj);\n        // If this was the last capturing object for this pointer\n        if (captures.size === 0) {\n            capturedMap.delete(pointerId);\n            captureData.target.releasePointerCapture(pointerId);\n        }\n    }\n}\n\nexport function removeInteractivity(stateFactory: NgtStateFactory, object: THREE.Object3D) {\n    const { internal } = stateFactory();\n    // Removes every trace of an object from the data store\n    internal.interaction = internal.interaction.filter((o) => o !== object);\n    internal.initialHits = internal.initialHits.filter((o) => o !== object);\n    internal.hovered.forEach((value, key) => {\n        if (value.eventObject === object || value.object === object) {\n            // Clear out intersects, they are outdated by now\n            internal.hovered.delete(key);\n        }\n    });\n    internal.capturedMap.forEach((captures, pointerId) => {\n        releaseInternalPointerCapture(internal.capturedMap, object, captures, pointerId);\n    });\n}\n\nexport function createEvents(stateFactory: NgtStateFactory) {\n    /** Calculates delta */\n    function calculateDistance(event: NgtDomEvent) {\n        const { internal } = stateFactory();\n        const dx = event.offsetX - internal.initialClick[0];\n        const dy = event.offsetY - internal.initialClick[1];\n        return Math.round(Math.sqrt(dx * dx + dy * dy));\n    }\n\n    /** Returns true if an instance has a valid pointer-event registered, this excludes scroll, clicks etc */\n    function filterPointerEvents(objects: THREE.Object3D[]) {\n        return objects.filter((obj) =>\n            ['move', 'over', 'enter', 'out', 'leave'].some((name) => {\n                const eventName = ('pointer' + name) as keyof NgtEventHandlers;\n                return getInstanceLocalState(obj)?.handlers[eventName];\n            })\n        );\n    }\n\n    function intersect(event: NgtDomEvent, filter?: (objects: THREE.Object3D[]) => THREE.Object3D[]) {\n        const state = stateFactory();\n        const duplicates = new Set<string>();\n        const intersections: NgtIntersection[] = [];\n        // Allow callers to eliminate event objects\n        const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction;\n        // Reset all raycaster cameras to undefined\n        for (let i = 0; i < eventsObjects.length; i++) {\n            const instanceState = getInstanceLocalState(eventsObjects[i])?.stateFactory();\n            if (instanceState) {\n                instanceState.raycaster.camera = undefined!;\n            }\n        }\n\n        if (!state.previousStateFactory) {\n            // Make sure root-level pointer and ray are set up\n            state.events.compute?.(event, () => state);\n        }\n\n        function handleRaycast(obj: THREE.Object3D<THREE.Event>) {\n            const state = getInstanceLocalState(obj)?.stateFactory();\n            // Skip event handling when noEvents is set, or when the raycasters camera is null\n            if (!state || !state.events.enabled || state.raycaster.camera === null) return [];\n\n            // When the camera is undefined we have to call the event layers update function\n            if (state.raycaster.camera === undefined) {\n                state.events.compute?.(event, () => state, state.previousStateFactory);\n                // If the camera is still undefined we have to skip this layer entirely\n                if (state.raycaster.camera === undefined) state.raycaster.camera = null!;\n            }\n\n            // Intersect object by object\n            return state.raycaster.camera ? state.raycaster.intersectObject(obj, true) : [];\n        }\n\n        // Collect events\n        let hits: THREE.Intersection<THREE.Object3D<THREE.Event>>[] = eventsObjects\n            // Intersect objects\n            .flatMap(handleRaycast)\n            // Sort by event priority and distance\n            .sort((a, b) => {\n                const aState = getInstanceLocalState(a.object)?.stateFactory();\n                const bState = getInstanceLocalState(b.object)?.stateFactory();\n                if (!aState || !bState) return 0;\n                return bState.events.priority - aState.events.priority || a.distance - b.distance;\n            })\n            // Filter out duplicates\n            .filter((item) => {\n                const id = makeId(item as NgtIntersection);\n                if (duplicates.has(id)) return false;\n                duplicates.add(id);\n                return true;\n            });\n\n        // https://github.com/mrdoob/three.js/issues/16031\n        // Allow custom userland intersect sort order, this likely only makes sense on the root filter\n        if (state.events.filter) hits = state.events.filter(hits, () => state);\n\n        // Bubble up the events, find the event source (eventObject)\n        for (const hit of hits) {\n            let eventObject: THREE.Object3D | null = hit.object;\n            // Bubble event up\n            while (eventObject) {\n                if (getInstanceLocalState(eventObject)?.eventCount) intersections.push({ ...hit, eventObject });\n                eventObject = eventObject.parent;\n            }\n        }\n\n        // If the interaction is captured, make all capturing targets part of the intersect.\n        if ('pointerId' in event && state.internal.capturedMap.has(event.pointerId)) {\n            for (const captureData of state.internal.capturedMap.get(event.pointerId)!.values()) {\n                intersections.push(captureData.intersection);\n            }\n        }\n        return intersections;\n    }\n\n    /**  Handles intersections by forwarding them to handlers */\n    function handleIntersects(\n        intersections: NgtIntersection[],\n        event: NgtDomEvent,\n        delta: number,\n        callback: (event: NgtThreeEvent<NgtDomEvent>) => void\n    ) {\n        const rootState = stateFactory();\n        // If anything has been found, forward it to the event listeners\n        if (intersections.length) {\n            const localState = { stopped: false };\n            for (const hit of intersections) {\n                const state = getInstanceLocalState(hit.object)?.stateFactory() || rootState;\n                const { raycaster, pointer, camera, internal } = state;\n                const unprojectedPoint = new THREE.Vector3(pointer.x, pointer.y, 0).unproject(camera);\n                const hasPointerCapture = (id: number) => internal.capturedMap.get(id)?.has(hit.eventObject) ?? false;\n\n                const setPointerCapture = (id: number) => {\n                    const captureData = {\n                        intersection: hit,\n                        target: event.target as Element,\n                    };\n                    if (internal.capturedMap.has(id)) {\n                        // if the pointerId was previously captured, we add the hit to the\n                        // event capturedMap.\n                        internal.capturedMap.get(id)!.set(hit.eventObject, captureData);\n                    } else {\n                        // if the pointerId was not previously captured, we create a map\n                        // containing the hitObject, and the hit. hitObject is used for\n                        // faster access.\n                        internal.capturedMap.set(id, new Map([[hit.eventObject, captureData]]));\n                    }\n                    // Call the original event now\n                    (event.target as Element).setPointerCapture(id);\n                };\n\n                const releasePointerCapture = (id: number) => {\n                    const captures = internal.capturedMap.get(id);\n                    if (captures) {\n                        releaseInternalPointerCapture(internal.capturedMap, hit.eventObject, captures, id);\n                    }\n                };\n\n                // Add native event props\n                const extractEventProps: any = {};\n                // This iterates over the event's properties including the inherited ones. Native PointerEvents have most of their props as getters which are inherited, but polyfilled PointerEvents have them all as their own properties (i.e. not inherited). We can't use Object.keys() or Object.entries() as they only return \"own\" properties; nor Object.getPrototypeOf(event) as that *doesn't* return \"own\" properties, only inherited ones.\n                for (const prop in event) {\n                    const property = event[prop as keyof NgtDomEvent];\n                    // Only copy over atomics, leave functions alone as these should be\n                    // called as event.nativeEvent.fn()\n                    if (typeof property !== 'function') extractEventProps[prop] = property;\n                }\n\n                const raycastEvent: NgtThreeEvent<NgtDomEvent> = {\n                    ...hit,\n                    ...extractEventProps,\n                    pointer,\n                    intersections,\n                    stopped: localState.stopped,\n                    delta,\n                    unprojectedPoint,\n                    ray: raycaster.ray,\n                    camera: camera,\n                    // Hijack stopPropagation, which just sets a flag\n                    stopPropagation() {\n                        // https://github.com/pmndrs/react-three-fiber/issues/596\n                        // Events are not allowed to stop propagation if the pointer has been captured\n                        const capturesForPointer = 'pointerId' in event && internal.capturedMap.get(event.pointerId);\n\n                        // We only authorize stopPropagation...\n                        if (\n                            // ...if this pointer hasn't been captured\n                            !capturesForPointer ||\n                            // ... or if the hit object is capturing the pointer\n                            capturesForPointer.has(hit.eventObject)\n                        ) {\n                            raycastEvent.stopped = localState.stopped = true;\n                            // Propagation is stopped, remove all other hover records\n                            // An event handler is only allowed to flush other handlers if it is hovered itself\n                            if (\n                                internal.hovered.size &&\n                                Array.from(internal.hovered.values()).find((i) => i.eventObject === hit.eventObject)\n                            ) {\n                                // Objects cannot flush out higher up objects that have already caught the event\n                                const higher = intersections.slice(0, intersections.indexOf(hit));\n                                cancelPointer([...higher, hit]);\n                            }\n                        }\n                    },\n                    // there should be a distinction between target and currentTarget\n                    target: {\n                        hasPointerCapture,\n                        setPointerCapture,\n                        releasePointerCapture,\n                    },\n                    currentTarget: {\n                        hasPointerCapture,\n                        setPointerCapture,\n                        releasePointerCapture,\n                    },\n                    nativeEvent: event,\n                };\n\n                // Call subscribers\n                callback(raycastEvent);\n                // Event bubbling may be interrupted by stopPropagation\n                if (localState.stopped === true) break;\n            }\n        }\n        return intersections;\n    }\n\n    function cancelPointer(intersections: NgtIntersection[]) {\n        const { internal } = stateFactory();\n        for (const hoveredObj of internal.hovered.values()) {\n            // When no objects were hit or the hovered object wasn't found underneath the cursor\n            // we call onPointerOut and delete the object from the hovered-elements map\n            if (\n                !intersections.length ||\n                !intersections.find(\n                    (hit) =>\n                        hit.object === hoveredObj.object &&\n                        hit.index === hoveredObj.index &&\n                        hit.instanceId === hoveredObj.instanceId\n                )\n            ) {\n                const eventObject = hoveredObj.eventObject;\n                const instance = getInstanceLocalState(eventObject);\n                const handlers = instance?.handlers;\n                internal.hovered.delete(makeId(hoveredObj));\n                if (instance?.eventCount) {\n                    // Clear out intersects, they are outdated by now\n                    const data = { ...hoveredObj, intersections };\n                    handlers?.pointerout?.(data as NgtThreeEvent<PointerEvent>);\n                    handlers?.pointerleave?.(data as NgtThreeEvent<PointerEvent>);\n                }\n            }\n        }\n    }\n\n    function pointerMissed(event: MouseEvent, objects: THREE.Object3D[]) {\n        for (let i = 0; i < objects.length; i++) {\n            const instance = getInstanceLocalState(objects[i]);\n            instance?.handlers.pointermissed?.(event);\n        }\n    }\n\n    function handlePointer(name: string) {\n        // Deal with cancelation\n        switch (name) {\n            case 'pointerleave':\n            case 'pointercancel':\n                return () => cancelPointer([]);\n            case 'lostpointercapture':\n                return (event: NgtDomEvent) => {\n                    const { internal } = stateFactory();\n                    if ('pointerId' in event && !internal.capturedMap.has(event.pointerId)) {\n                        // If the object event interface had onLostPointerCapture, we'd call it here on every\n                        // object that's getting removed.\n                        internal.capturedMap.delete(event.pointerId);\n                        cancelPointer([]);\n                    }\n                };\n        }\n\n        // Any other pointer goes here ...\n        return function handleEvent(event: NgtDomEvent) {\n            const { onPointerMissed, internal } = stateFactory();\n\n            // prepareRay(event)\n            internal.lastEvent = event;\n\n            // Get fresh intersects\n            const isPointerMove = name === 'pointermove';\n            const isClickEvent = name === 'click' || name === 'contextmenu' || name === 'dblclick';\n            const filter = isPointerMove ? filterPointerEvents : undefined;\n            // const hits = patchIntersects(intersect(filter), event)\n            const hits = intersect(event, filter);\n            const delta = isClickEvent ? calculateDistance(event) : 0;\n\n            // Save initial coordinates on pointer-down\n            if (name === 'pointerdown') {\n                internal.initialClick = [event.offsetX, event.offsetY];\n                internal.initialHits = hits.map((hit) => hit.eventObject);\n            }\n\n            // If a click yields no results, pass it back to the user as a miss\n            // Missed events have to come first in order to establish user-land side-effect clean up\n            if (isClickEvent && !hits.length) {\n                if (delta <= 2) {\n                    pointerMissed(event, internal.interaction);\n                    if (onPointerMissed) onPointerMissed(event);\n                }\n            }\n            // Take care of unhover\n            if (isPointerMove) cancelPointer(hits);\n\n            function onIntersect(data: NgtThreeEvent<NgtDomEvent>) {\n                const eventObject = data.eventObject;\n                const instance = getInstanceLocalState(eventObject);\n                const handlers = instance?.handlers;\n                // Check presence of handlers\n                if (!instance?.eventCount) return;\n\n                if (isPointerMove) {\n                    // Move event ...\n                    if (\n                        handlers?.pointerover ||\n                        handlers?.pointerenter ||\n                        handlers?.pointerout ||\n                        handlers?.pointerleave\n                    ) {\n                        // When enter or out is present take care of hover-state\n                        const id = makeId(data);\n                        const hoveredItem = internal.hovered.get(id);\n                        if (!hoveredItem) {\n                            // If the object wasn't previously hovered, book it and call its handler\n                            internal.hovered.set(id, data);\n                            handlers.pointerover?.(data as NgtThreeEvent<PointerEvent>);\n                            handlers.pointerenter?.(data as NgtThreeEvent<PointerEvent>);\n                        } else if (hoveredItem.stopped) {\n                            // If the object was previously hovered and stopped, we shouldn't allow other items to proceed\n                            data.stopPropagation();\n                        }\n                    }\n                    // Call mouse move\n                    handlers?.pointermove?.(data as NgtThreeEvent<PointerEvent>);\n                } else {\n                    // All other events ...\n                    const handler = handlers![name as keyof NgtEventHandlers] as (\n                        event: NgtThreeEvent<PointerEvent>\n                    ) => void;\n                    if (handler) {\n                        // Forward all events back to their respective handlers with the exception of click events,\n                        // which must use the initial target\n                        if (!isClickEvent || internal.initialHits.includes(eventObject)) {\n                            // Missed events have to come first\n                            pointerMissed(\n                                event,\n                                internal.interaction.filter((object) => !internal.initialHits.includes(object))\n                            );\n                            // Now call the handler\n                            handler(data as NgtThreeEvent<PointerEvent>);\n                        }\n                    } else {\n                        // Trigger onPointerMissed on all elements that have pointer over/out handlers, but not click and weren't hit\n                        if (isClickEvent && internal.initialHits.includes(eventObject)) {\n                            pointerMissed(\n                                event,\n                                internal.interaction.filter((object) => !internal.initialHits.includes(object))\n                            );\n                        }\n                    }\n                }\n            }\n\n            handleIntersects(hits, event, delta, onIntersect);\n        };\n    }\n\n    return { handlePointer };\n}\n"]}

package/esm2020/lib/utils/get-instance-local-state.mjs

@@ -0,0 +1,6 @@
+export function getInstanceLocalState(obj) {
+    if (!obj)
+        return undefined;
+    return obj['__ngt__'];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWluc3RhbmNlLWxvY2FsLXN0YXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhci10aHJlZS9zcmMvbGliL3V0aWxzL2dldC1pbnN0YW5jZS1sb2NhbC1zdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLFVBQVUscUJBQXFCLENBQ2pDLEdBQTBCO0lBRTFCLElBQUksQ0FBQyxHQUFHO1FBQUUsT0FBTyxTQUFTLENBQUM7SUFDM0IsT0FBUSxHQUFvQixDQUFDLFNBQVMsQ0FBMEIsQ0FBQztBQUNyRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBOZ3RBbnlSZWNvcmQsIE5ndEluc3RhbmNlTG9jYWxTdGF0ZSB9IGZyb20gJy4uL3R5cGVzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGdldEluc3RhbmNlTG9jYWxTdGF0ZTxUSW5zdGFuY2UgZXh0ZW5kcyBvYmplY3QgPSBOZ3RBbnlSZWNvcmQ+KFxuICAgIG9iajogVEluc3RhbmNlIHwgdW5kZWZpbmVkXG4pOiBOZ3RJbnN0YW5jZUxvY2FsU3RhdGUgfCB1bmRlZmluZWQge1xuICAgIGlmICghb2JqKSByZXR1cm4gdW5kZWZpbmVkO1xuICAgIHJldHVybiAob2JqIGFzIE5ndEFueVJlY29yZClbJ19fbmd0X18nXSBhcyBOZ3RJbnN0YW5jZUxvY2FsU3RhdGU7XG59XG4iXX0=

package/esm2020/lib/utils/inject.mjs

@@ -0,0 +1,18 @@
+import { inject, InjectionToken } from '@angular/core';
+export function createInjection(description, { defaultValueOrFactory, provideValueFactory, } = {}) {
+    const factory = (defaultValueOrFactory && typeof defaultValueOrFactory === 'function'
+        ? defaultValueOrFactory
+        : () => defaultValueOrFactory);
+    const injectionToken = new InjectionToken(description, { factory });
+    function injectFn(options = {}) {
+        return inject(injectionToken, options);
+    }
+    function provideFn(value) {
+        return {
+            provide: injectionToken,
+            useValue: provideValueFactory ? provideValueFactory(value) : value,
+        };
+    }
+    return [injectFn, provideFn, injectionToken];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/instance.mjs

@@ -0,0 +1,35 @@
+import { NgtRef } from '../ref';
+import { applyProps } from './apply-props';
+import { checkUpdate } from './check-update';
+import { getInstanceLocalState } from './get-instance-local-state';
+import { is } from './is';
+export function invalidateInstance(instance) {
+    const state = getInstanceLocalState(instance)?.stateFactory();
+    if (state && state.internal.frames === 0)
+        state.invalidate();
+    checkUpdate(instance);
+}
+export function prepare(instance, parentStateFactory, rootStateFactory, parentInstance, previousInstance, isPrimitive = false) {
+    const previousInstanceInternal = getInstanceLocalState(previousInstance?.value);
+    const parent = parentInstance
+        ? parentInstance
+        : previousInstanceInternal
+            ? previousInstanceInternal.parentRef
+            : undefined;
+    if (is.scene(instance)) {
+        applyProps(instance, { dispose: null });
+    }
+    return Object.assign(instance, {
+        __ngt__: {
+            stateFactory: parentStateFactory,
+            rootFactory: rootStateFactory,
+            isPrimitive: !isPrimitive ? previousInstanceInternal?.isPrimitive : isPrimitive,
+            eventCount: previousInstanceInternal?.eventCount ?? 0,
+            handlers: previousInstanceInternal?.handlers ?? {},
+            instancesRefs: previousInstanceInternal?.instancesRefs ?? new NgtRef([]),
+            objectsRefs: previousInstanceInternal?.objectsRefs ?? new NgtRef([]),
+            parentRef: parent ? (parent === instance || parent.value === instance ? null : parent) : null,
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/is.mjs

@@ -0,0 +1,54 @@
+import * as THREE from 'three';
+import { NgtRef } from '../ref';
+export const is = {
+    obj: (a) => a === Object(a) && !Array.isArray(a) && typeof a !== 'function',
+    material: (a) => !!a && a.isMaterial,
+    geometry: (a) => !!a && a.isBufferGeometry,
+    mesh: (a) => !!a && a.isMesh,
+    color: (a) => !!a && a.isColor,
+    orthographic: (a) => !!a && a.isOrthographicCamera,
+    perspective: (a) => !!a && a.isPerspectiveCamera,
+    camera: (a) => !!a && a.isCamera,
+    glRenderer: (a) => !!a && a instanceof THREE.WebGLRenderer,
+    scene: (a) => !!a && a.isScene,
+    object3d: (a) => !!a && a.isObject3D,
+    instance: (a) => !!a && !!a['__ngt__'],
+    ref: (a) => !!a && a instanceof NgtRef,
+    supportColorManagement: () => 'ColorManagement' in THREE,
+    canvas: (a) => a instanceof HTMLCanvasElement,
+    equ(a, b, { arrays = 'shallow', objects = 'reference', strict = true } = {}) {
+        // Wrong type or one of the two undefined, doesn't match
+        if (typeof a !== typeof b || !!a !== !!b)
+            return false;
+        // Atomic, just compare a against b
+        if (typeof a === 'string' || typeof a === 'number')
+            return a === b;
+        const isObj = is.obj(a);
+        if (isObj && objects === 'reference')
+            return a === b;
+        const isArr = Array.isArray(a);
+        if (isArr && arrays === 'reference')
+            return a === b;
+        // Array or Object, shallow compare first to see if it's a match
+        if ((isArr || isObj) && a === b)
+            return true;
+        // Last resort, go through keys
+        let i;
+        for (i in a)
+            if (!(i in b))
+                return false;
+        for (i in strict ? b : a)
+            if (a[i] !== b[i])
+                return false;
+        if (i === void 0) {
+            if (isArr && a.length === 0 && b.length === 0)
+                return true;
+            if (isObj && Object.keys(a).length === 0 && Object.keys(b).length === 0)
+                return true;
+            if (a !== b)
+                return false;
+        }
+        return true;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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