@latticexyz/recs 2.0.0-next.0 → 2.0.0-next.10

package/src/Query.ts

@@ -1,6 +1,6 @@
 import { filterNullish } from "@latticexyz/utils";
 import { observable, ObservableSet } from "mobx";
-import { concat, concatMap, filter, from, map, merge, Observable, of, Subject } from "rxjs";
+import { concat, concatMap, filter, from, map, merge, Observable, of, share, Subject } from "rxjs";
 import {
   componentValueEquals,
   getComponentEntities,
@@ -506,22 +506,9 @@ export function defineQuery(
       filterNullish()
     );
 
-  // Create a new Subject to allow multiple observers
-  // but only subscribe to the internal stream when the update stream is
-  // subscribed to, in order to get the same behavior as if exposing the
-  // internal stream directly (ie only running the internal$ pipe if there are subscribers)
-  const update$ = new Subject<ComponentUpdate & { type: UpdateType }>();
-  const world = fragments[0].component.world;
-  const subscribe = update$.subscribe.bind(update$);
-  update$.subscribe = (observer) => {
-    const subscription = internal$.subscribe(update$);
-    world.registerDisposer(() => subscription?.unsubscribe());
-    return subscribe(observer as Parameters<typeof subscribe>[0]);
-  };
-
   return {
     matching,
-    update$: concat(initial$, update$),
+    update$: concat(initial$, internal$).pipe(share()),
   };
 }
 

package/src/System.spec.ts

@@ -0,0 +1,139 @@
+import { defineComponent, removeComponent, setComponent, withValue } from "./Component";
+import { Type, UpdateType } from "./constants";
+import { createEntity } from "./Entity";
+import { Has } from "./Query";
+import { defineEnterSystem, defineExitSystem, defineSystem, defineUpdateSystem } from "./System";
+import { Component, Entity, World } from "./types";
+import { createWorld } from "./World";
+
+describe("System", () => {
+  let world: World;
+
+  beforeEach(() => {
+    world = createWorld();
+  });
+
+  describe("Systems", () => {
+    let Position: Component<{ x: number; y: number }>;
+    let entity: Entity;
+
+    beforeEach(() => {
+      Position = defineComponent(world, { x: Type.Number, y: Type.Number });
+      entity = createEntity(world, [withValue(Position, { x: 1, y: 2 })]);
+    });
+
+    it("defineSystem should rerun the system if the query result changes (enter, update, exit)", () => {
+      const mock = jest.fn();
+      defineSystem(world, [Has(Position)], mock);
+
+      setComponent(Position, entity, { x: 2, y: 3 });
+
+      expect(mock).toHaveBeenCalledTimes(2);
+      expect(mock).toHaveBeenCalledWith({
+        entity,
+        component: Position,
+        value: [
+          { x: 2, y: 3 },
+          { x: 1, y: 2 },
+        ],
+        type: UpdateType.Update,
+      });
+
+      setComponent(Position, entity, { x: 3, y: 3 });
+      expect(mock).toHaveBeenCalledTimes(3);
+      expect(mock).toHaveBeenCalledWith({
+        entity,
+        component: Position,
+        value: [
+          { x: 3, y: 3 },
+          { x: 2, y: 3 },
+        ],
+        type: UpdateType.Update,
+      });
+
+      removeComponent(Position, entity);
+      expect(mock).toHaveBeenCalledTimes(4);
+      expect(mock).toHaveBeenCalledWith({
+        entity,
+        component: Position,
+        value: [undefined, { x: 3, y: 3 }],
+        type: UpdateType.Exit,
+      });
+    });
+
+    it("defineUpdateSystem should rerun the system if the component value of an entity matchign the query changes", () => {
+      const mock = jest.fn();
+      defineUpdateSystem(world, [Has(Position)], mock);
+
+      // The entity already had a position when the system was created and the system runs on init,
+      // so this position update is an update
+      setComponent(Position, entity, { x: 2, y: 3 });
+      expect(mock).toHaveBeenCalledTimes(1);
+
+      setComponent(Position, entity, { x: 2, y: 3 });
+      expect(mock).toHaveBeenCalledTimes(2);
+      expect(mock).toHaveBeenCalledWith({
+        entity,
+        component: Position,
+        value: [
+          { x: 2, y: 3 },
+          { x: 2, y: 3 },
+        ],
+        type: UpdateType.Update,
+      });
+
+      // Setting the same value again should rerun the system
+      setComponent(Position, entity, { x: 2, y: 3 });
+      expect(mock).toHaveBeenCalledTimes(3);
+
+      setComponent(Position, entity, { x: 3, y: 3 });
+      expect(mock).toHaveBeenCalledTimes(4);
+    });
+
+    it("defineEnterSystem should rerun once with entities matching the query for the first time", () => {
+      const CanMove = defineComponent(world, { value: Type.Boolean });
+      const mock = jest.fn();
+
+      defineEnterSystem(world, [Has(CanMove)], mock);
+
+      const entity1 = createEntity(world, [withValue(CanMove, { value: true })]);
+
+      expect(mock).toHaveBeenCalledTimes(1);
+      expect(mock).toHaveBeenCalledWith(
+        expect.objectContaining({ entity: entity1, component: CanMove, value: [{ value: true }, undefined] })
+      );
+
+      const entity2 = createEntity(world, [withValue(CanMove, { value: true })]);
+      expect(mock).toHaveBeenCalledTimes(2);
+      expect(mock).toHaveBeenCalledWith(
+        expect.objectContaining({ entity: entity2, component: CanMove, value: [{ value: true }, undefined] })
+      );
+    });
+
+    it("defineExitSystem should rerun once with entities not matching the query anymore", () => {
+      const CanMove = defineComponent(world, { value: Type.Boolean });
+
+      const mock = jest.fn();
+      defineExitSystem(world, [Has(CanMove)], mock);
+
+      const entity1 = createEntity(world, [withValue(CanMove, { value: true })]);
+      const entity2 = createEntity(world);
+      setComponent(CanMove, entity2, { value: true });
+
+      expect(mock).toHaveBeenCalledTimes(0);
+
+      removeComponent(CanMove, entity1);
+
+      expect(mock).toHaveBeenCalledTimes(1);
+      expect(mock).toHaveBeenCalledWith(
+        expect.objectContaining({ entity: entity1, component: CanMove, value: [undefined, { value: true }] })
+      );
+
+      removeComponent(CanMove, entity2);
+      expect(mock).toHaveBeenCalledTimes(2);
+      expect(mock).toHaveBeenCalledWith(
+        expect.objectContaining({ entity: entity2, component: CanMove, value: [undefined, { value: true }] })
+      );
+    });
+  });
+});

package/src/World.spec.ts

@@ -0,0 +1,79 @@
+import { arrayToIterator } from "@latticexyz/utils";
+import { Subject } from "rxjs";
+import { defineComponent, setComponent } from "./Component";
+import { Type } from "./constants";
+import { createEntity } from "./Entity";
+import { World, AnyComponent, EntitySymbol } from "./types";
+import { createWorld, getEntityComponents } from "./World";
+
+describe("World", () => {
+  describe("createWorld", () => {
+    let world: World;
+
+    beforeEach(() => {
+      world = createWorld();
+    });
+
+    describe("registerEntity", () => {
+      it("should add the entitiy to the world's entities", () => {
+        expect([...world.getEntities()].length).toBe(0);
+
+        world.registerEntity();
+        expect([...world.getEntities()].length).toBe(1);
+        expect([...world.getEntities()][0]).not.toBe(undefined);
+      });
+    });
+
+    describe("registerComponent", () => {
+      let rawComponent: AnyComponent;
+
+      beforeEach(() => {
+        rawComponent = {
+          id: "some-id",
+          values: {
+            value: new Map<EntitySymbol, number>(),
+          },
+          update$: new Subject(),
+          schema: { value: Type.Number },
+          metadata: {},
+          entities: () => arrayToIterator([]),
+          world,
+        };
+      });
+
+      it("should add the component to the world's components", () => {
+        expect(world.components.length).toBe(0);
+        world.registerComponent(rawComponent);
+        expect(world.components.length).toBe(1);
+        expect(world.components.includes(rawComponent)).toBe(true);
+      });
+
+      describe("getEntitiyComponents", () => {
+        it("should return the set of components of a given entity", () => {
+          const components = new Set<AnyComponent>([
+            defineComponent(world, { value: Type.Number }),
+            defineComponent(world, { value: Type.Number }),
+            defineComponent(world, { value: Type.Number }),
+          ]);
+          const entity = createEntity(world);
+          const value = 1;
+
+          for (const component of components) {
+            setComponent(component, entity, { value });
+          }
+
+          const received = getEntityComponents(world, entity);
+          expect(received.length).toEqual(components.size);
+
+          for (const comp of received) {
+            expect(components.has(comp)).toBe(true);
+          }
+
+          for (const comp of components) {
+            expect(received.includes(comp)).toBe(true);
+          }
+        });
+      });
+    });
+  });
+});

package/src/deprecated/constants.ts

@@ -0,0 +1,9 @@
+export enum ActionState {
+  Requested = "Requested",
+  Executing = "Executing",
+  WaitingForTxEvents = "WaitingForTxEvents",
+  Complete = "Complete",
+  Failed = "Failed",
+  Cancelled = "Cancelled",
+  TxReduced = "TxReduced",
+}