@blorkfield/overlay-core 0.10.1 → 0.11.0

package/dist/index.d.cts

@@ -595,6 +595,7 @@ declare class OverlayScene {
     private gravityOverrideEntries;
     private followWindowEntries;
     private pressureObstacleIds;
+    private activeCollisions;
     static createContainer(parent: HTMLElement, options?: ContainerOptions): {
         canvas: HTMLCanvasElement;
         bounds: Bounds;
@@ -623,6 +624,7 @@ declare class OverlayScene {
      * Emits objectCollision lifecycle events.
      */
     private handleCollisionStart;
+    private handleCollisionEnd;
     /** Get a display name for an obstacle (letter char or short ID) */
     private getObstacleDisplayName;
     /** Update pressure tracking - check which dynamic objects rest on static obstacles */
@@ -860,6 +862,20 @@ declare class OverlayScene {
      * @param callback - The callback to remove
      */
     off<T extends LifecycleEvent>(event: T, callback: LifecycleCallback<T>): void;
+    /**
+     * Get the IDs of all objects currently colliding with a given object.
+     * @param id - The ID of the object to query
+     * @returns Array of IDs of objects currently in contact with it
+     */
+    getCollidingWith(id: string): string[];
+    /**
+     * Get all currently active collision pairs.
+     * @returns Array of `{ a, b }` pairs where `a` and `b` are colliding object IDs
+     */
+    getActiveCollisions(): Array<{
+        a: string;
+        b: string;
+    }>;
     /** Create ObjectState from an ObjectEntry */
     private toObjectState;
     /** Emit a lifecycle event to all registered callbacks */

package/dist/index.d.ts

@@ -595,6 +595,7 @@ declare class OverlayScene {
     private gravityOverrideEntries;
     private followWindowEntries;
     private pressureObstacleIds;
+    private activeCollisions;
     static createContainer(parent: HTMLElement, options?: ContainerOptions): {
         canvas: HTMLCanvasElement;
         bounds: Bounds;
@@ -623,6 +624,7 @@ declare class OverlayScene {
      * Emits objectCollision lifecycle events.
      */
     private handleCollisionStart;
+    private handleCollisionEnd;
     /** Get a display name for an obstacle (letter char or short ID) */
     private getObstacleDisplayName;
     /** Update pressure tracking - check which dynamic objects rest on static obstacles */
@@ -860,6 +862,20 @@ declare class OverlayScene {
      * @param callback - The callback to remove
      */
     off<T extends LifecycleEvent>(event: T, callback: LifecycleCallback<T>): void;
+    /**
+     * Get the IDs of all objects currently colliding with a given object.
+     * @param id - The ID of the object to query
+     * @returns Array of IDs of objects currently in contact with it
+     */
+    getCollidingWith(id: string): string[];
+    /**
+     * Get all currently active collision pairs.
+     * @returns Array of `{ a, b }` pairs where `a` and `b` are colliding object IDs
+     */
+    getActiveCollisions(): Array<{
+        a: string;
+        b: string;
+    }>;
     /** Create ObjectState from an ObjectEntry */
     private toObjectState;
     /** Emit a lifecycle event to all registered callbacks */

package/dist/index.js

@@ -1414,6 +1414,8 @@ var OverlayScene = class {
     this.followWindowEntries = /* @__PURE__ */ new Set();
     // IDs of static objects that have pressure thresholds — empty = skip updatePressure entirely
     this.pressureObstacleIds = /* @__PURE__ */ new Set();
+    // Active collision pairs: id -> Set of ids currently colliding with it
+    this.activeCollisions = /* @__PURE__ */ new Map();
     /** Handle mouse down - start grab via programmatic API */
     this.handleMouseDown = (event) => {
       const rect = this.canvas.getBoundingClientRect();
@@ -1480,6 +1482,10 @@ var OverlayScene = class {
         const entryA = this.findObjectByBody(pair.bodyA);
         const entryB = this.findObjectByBody(pair.bodyB);
         if (entryA && entryB) {
+          if (!this.activeCollisions.has(entryA.id)) this.activeCollisions.set(entryA.id, /* @__PURE__ */ new Set());
+          if (!this.activeCollisions.has(entryB.id)) this.activeCollisions.set(entryB.id, /* @__PURE__ */ new Set());
+          this.activeCollisions.get(entryA.id).add(entryB.id);
+          this.activeCollisions.get(entryB.id).add(entryA.id);
           this.emitLifecycleEvent(
             "objectCollision",
             this.toObjectState(entryA),
@@ -1488,6 +1494,16 @@ var OverlayScene = class {
         }
       }
     };
+    this.handleCollisionEnd = (event) => {
+      for (const pair of event.pairs) {
+        const entryA = this.findObjectByBody(pair.bodyA);
+        const entryB = this.findObjectByBody(pair.bodyB);
+        if (entryA && entryB) {
+          this.activeCollisions.get(entryA.id)?.delete(entryB.id);
+          this.activeCollisions.get(entryB.id)?.delete(entryA.id);
+        }
+      }
+    };
     // ==================== PRIVATE ====================
     this.loop = () => {
       const substepDelta = 1e3 / 60 / this.substeps;
@@ -1616,6 +1632,7 @@ var OverlayScene = class {
     Matter5.Events.on(this.render, "beforeRender", this.handleBeforeRender);
     Matter5.Events.on(this.render, "afterRender", this.handleAfterRender);
     Matter5.Events.on(this.engine, "collisionStart", this.handleCollisionStart);
+    Matter5.Events.on(this.engine, "collisionEnd", this.handleCollisionEnd);
   }
   static createContainer(parent, options = {}) {
     const canvas = document.createElement("canvas");
@@ -2019,6 +2036,7 @@ var OverlayScene = class {
     Matter5.Events.off(this.render, "beforeRender", this.handleBeforeRender);
     Matter5.Events.off(this.render, "afterRender", this.handleAfterRender);
     Matter5.Events.off(this.engine, "collisionStart", this.handleCollisionStart);
+    Matter5.Events.off(this.engine, "collisionEnd", this.handleCollisionEnd);
     Matter5.Engine.clear(this.engine);
     this.objects.clear();
     this.gravityOverrideEntries.clear();
@@ -2029,6 +2047,7 @@ var OverlayScene = class {
     this.pressureLogTimer = 0;
     this.floorSegmentPressure.clear();
     this.collapsedSegments.clear();
+    this.activeCollisions.clear();
     this.updateCallbacks = [];
     this.lifecycleCallbacks.objectSpawned = [];
     this.lifecycleCallbacks.objectRemoved = [];
@@ -2480,6 +2499,13 @@ var OverlayScene = class {
     this.gravityOverrideEntries.delete(entry);
     this.followWindowEntries.delete(entry);
     this.pressureObstacleIds.delete(id);
+    const colliding = this.activeCollisions.get(id);
+    if (colliding) {
+      for (const otherId of colliding) {
+        this.activeCollisions.get(otherId)?.delete(id);
+      }
+      this.activeCollisions.delete(id);
+    }
     this.objects.delete(id);
   }
   removeObjects(ids) {
@@ -2729,6 +2755,32 @@ var OverlayScene = class {
     const idx = arr.indexOf(callback);
     if (idx !== -1) arr.splice(idx, 1);
   }
+  /**
+   * Get the IDs of all objects currently colliding with a given object.
+   * @param id - The ID of the object to query
+   * @returns Array of IDs of objects currently in contact with it
+   */
+  getCollidingWith(id) {
+    return Array.from(this.activeCollisions.get(id) ?? []);
+  }
+  /**
+   * Get all currently active collision pairs.
+   * @returns Array of `{ a, b }` pairs where `a` and `b` are colliding object IDs
+   */
+  getActiveCollisions() {
+    const pairs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const [id, others] of this.activeCollisions) {
+      for (const otherId of others) {
+        const key = id < otherId ? `${id}:${otherId}` : `${otherId}:${id}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          pairs.push({ a: id, b: otherId });
+        }
+      }
+    }
+    return pairs;
+  }
   /** Create ObjectState from an ObjectEntry */
   toObjectState(entry) {
     return {