fix(hooks): trigger on_remove hooks when deleting entities

Previously, deleting an entity via world.delete() did not trigger
on_remove callbacks for multi-component hooks. This fix ensures
lifecycle hooks are properly fired during entity destruction by
collecting removed components and calling triggerLifecycleHooks
after the entity is removed from its archetype.

Author: codehz

src/__tests__/world-multi-component-hooks.test.ts

@@ -3,6 +3,69 @@ import { component, relation, type EntityId } from "../core/entity";
 import { World } from "../core/world";
 
 describe("World - Multi-Component Hooks", () => {
+  it("should trigger init, set, remove events correctly when using array syntax with single element", () => {
+    const world = new World();
+    const A = component<number>();
+
+    const initCalls: { entityId: EntityId; value: number }[] = [];
+    const setCalls: { entityId: EntityId; value: number }[] = [];
+    const removeCalls: { entityId: EntityId; value: number }[] = [];
+
+    // First create an entity before registering the hook (for on_init test)
+    const existingEntity = world.spawn().with(A, 100).build();
+    world.sync();
+
+    // Register hook using array syntax with single element
+    world.hook([A], {
+      on_init: (entityId, value) => {
+        initCalls.push({ entityId, value });
+      },
+      on_set: (entityId, value) => {
+        setCalls.push({ entityId, value });
+      },
+      on_remove: (entityId, value) => {
+        removeCalls.push({ entityId, value });
+      },
+    });
+
+    // on_init should be triggered for existing entity
+    expect(initCalls.length).toBe(1);
+    expect(initCalls[0]!.entityId).toBe(existingEntity);
+    expect(initCalls[0]!.value).toBe(100);
+
+    // Create a new entity - should trigger on_set
+    const newEntity = world.spawn().with(A, 42).build();
+    world.sync();
+
+    expect(setCalls.length).toBe(1);
+    expect(setCalls[0]!.entityId).toBe(newEntity);
+    expect(setCalls[0]!.value).toBe(42);
+
+    // Update the component - should trigger on_set again
+    world.set(newEntity, A, 99);
+    world.sync();
+
+    expect(setCalls.length).toBe(2);
+    expect(setCalls[1]!.entityId).toBe(newEntity);
+    expect(setCalls[1]!.value).toBe(99);
+
+    // Remove the component - should trigger on_remove
+    world.remove(newEntity, A);
+    world.sync();
+
+    expect(removeCalls.length).toBe(1);
+    expect(removeCalls[0]!.entityId).toBe(newEntity);
+    expect(removeCalls[0]!.value).toBe(99);
+
+    // Delete the existing entity - should trigger on_remove
+    world.delete(existingEntity);
+    world.sync();
+
+    expect(removeCalls.length).toBe(2);
+    expect(removeCalls[1]!.entityId).toBe(existingEntity);
+    expect(removeCalls[1]!.value).toBe(100);
+  });
+
   it("should throw error when hook has no required components (only optional)", () => {
     const world = new World();
     const A = component<number>();

src/core/world.ts

@@ -135,24 +135,31 @@ export class World {
       const archetype = this.entityToArchetype.get(cur);
       if (!archetype) continue;
 
-      const componentReferences = Array.from(getEntityReferences(this.entityReferences, cur));
-      for (const [sourceEntityId, componentType] of componentReferences) {
-        const sourceArchetype = this.entityToArchetype.get(sourceEntityId);
-        if (!sourceArchetype) continue;
+      // Process entity references before removal
+      for (const [sourceEntityId, componentType] of getEntityReferences(this.entityReferences, cur)) {
+        if (!this.entityToArchetype.has(sourceEntityId)) continue;
 
         if (isCascadeDeleteRelation(componentType)) {
           if (!visited.has(sourceEntityId)) {
             queue.push(sourceEntityId);
           }
-          continue;
+        } else {
+          this.removeComponentImmediate(sourceEntityId, componentType, cur);
         }
-
-        this.removeComponentImmediate(sourceEntityId, componentType, cur);
       }
 
+      // Remove entity from archetype - this also cleans up dontFragment relations
+      // and returns all removed component data
       this.entityReferences.delete(cur);
-      archetype.removeEntity(cur);
+      const removedComponents = archetype.removeEntity(cur)!;
       this.entityToArchetype.delete(cur);
+
+      // Trigger lifecycle hooks for removed components
+      if (removedComponents.size > 0) {
+        const emptyArchetype = this.ensureArchetype([]);
+        triggerLifecycleHooks(this.createHooksContext(), cur, new Map(), removedComponents, archetype, emptyArchetype);
+      }
+
       this.cleanupArchetypesReferencingEntity(cur);
       this.entityIdManager.deallocate(cur);
     }