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

package/src/Component.spec.ts

@@ -0,0 +1,275 @@
+import {
+  defineComponent,
+  setComponent,
+  removeComponent,
+  getComponentValue,
+  hasComponent,
+  withValue,
+  componentValueEquals,
+  getEntitiesWithValue,
+  overridableComponent,
+} from "./Component";
+import { Type } from "./constants";
+import { createEntity, getEntitySymbol } from "./Entity";
+import { AnyComponent, Entity, World } from "./types";
+import { createWorld } from "./World";
+
+describe("Component", () => {
+  let world: World;
+
+  beforeEach(() => {
+    world = createWorld();
+  });
+
+  it("emit changes to its stream", () => {
+    const entity = createEntity(world);
+    const component = defineComponent(world, { x: Type.Number, y: Type.Number });
+
+    const mock = jest.fn();
+    component.update$.subscribe((update) => {
+      mock(update);
+    });
+
+    setComponent(component, entity, { x: 1, y: 2 });
+    setComponent(component, entity, { x: 7, y: 2 });
+    setComponent(component, entity, { x: 7, y: 2 });
+    removeComponent(component, entity);
+
+    expect(mock).toHaveBeenNthCalledWith(1, { entity, value: [{ x: 1, y: 2 }, undefined], component });
+    expect(mock).toHaveBeenNthCalledWith(2, {
+      entity,
+      component,
+      value: [
+        { x: 7, y: 2 },
+        { x: 1, y: 2 },
+      ],
+    });
+    expect(mock).toHaveBeenNthCalledWith(3, {
+      entity,
+      component,
+      value: [
+        { x: 7, y: 2 },
+        { x: 7, y: 2 },
+      ],
+    });
+    expect(mock).toHaveBeenNthCalledWith(4, { entity, component, value: [undefined, { x: 7, y: 2 }] });
+  });
+
+  describe("defineComponent", () => {
+    it("should register the component in the world", () => {
+      expect(world.components.length).toBe(0);
+      defineComponent(world, { value: Type.Boolean });
+      expect(world.components.length).toBe(1);
+    });
+  });
+
+  describe("setComponent", () => {
+    let component: AnyComponent;
+    let entity: Entity;
+    let value: number;
+
+    beforeEach(() => {
+      component = defineComponent(world, { value: Type.Number });
+      entity = createEntity(world);
+      value = 1;
+      setComponent(component, entity, { value });
+    });
+
+    it("should store the component value", () => {
+      expect(component.values.value.get(getEntitySymbol(entity))).toBe(value);
+    });
+
+    it("should store the entity", () => {
+      expect(hasComponent(component, entity)).toBe(true);
+    });
+
+    it.todo("should store the value array");
+  });
+
+  describe("removeComponent", () => {
+    let component: AnyComponent;
+    let entity: Entity;
+    let value: number;
+
+    beforeEach(() => {
+      component = defineComponent(world, { value: Type.Number });
+      entity = createEntity(world);
+      value = 1;
+      setComponent(component, entity, { value });
+      removeComponent(component, entity);
+    });
+
+    it("should remove the component value", () => {
+      expect(component.values.value.get(getEntitySymbol(entity))).toBe(undefined);
+    });
+
+    it("should remove the entity", () => {
+      expect(hasComponent(component, entity)).toBe(false);
+    });
+
+    // it("shouldremove the component from the entity's component set", () => {
+    //   expect(world.entities.get(entity)?.has(component)).toBe(false);
+    // });
+  });
+
+  describe("hasComponent", () => {
+    it("should return true if the entity has the component", () => {
+      const component = defineComponent(world, { x: Type.Number, y: Type.Number });
+      const entity = createEntity(world);
+      const value = { x: 1, y: 2 };
+      setComponent(component, entity, value);
+
+      expect(hasComponent(component, entity)).toEqual(true);
+    });
+  });
+
+  describe("getComponentValue", () => {
+    it("should return the correct component value", () => {
+      const component = defineComponent(world, { x: Type.Number, y: Type.Number });
+      const entity = createEntity(world);
+      const value = { x: 1, y: 2 };
+      setComponent(component, entity, value);
+
+      const receivedValue = getComponentValue(component, entity);
+      expect(receivedValue).toEqual(value);
+    });
+  });
+
+  describe("getComponentValueStrict", () => {
+    it.todo("should return the correct component value");
+    it.todo("should error if the component value does not exist");
+  });
+
+  describe("componentValueEquals", () => {
+    const value1 = { x: 1, y: 2, z: "x" };
+    const value2 = { x: 1, y: 2, z: "x" };
+    const value3 = { x: "1", y: 2, z: "x" };
+
+    expect(componentValueEquals(value1, value2)).toBe(true);
+    expect(componentValueEquals(value2, value3)).toBe(false);
+  });
+
+  describe("withValue", () => {
+    it("should return a ComponentWithValue", () => {
+      const component = defineComponent(world, { x: Type.Number, y: Type.Number });
+      const value = { x: 1, y: 2 };
+      const componentWithValue = withValue(component, value);
+      expect(componentWithValue).toEqual([component, value]);
+    });
+  });
+
+  describe("getEntitiesWithValue", () => {
+    it("Should return all and only entities with this value", () => {
+      const Position = defineComponent(world, { x: Type.Number, y: Type.Number });
+      const entity1 = createEntity(world, [withValue(Position, { x: 1, y: 2 })]);
+      createEntity(world, [withValue(Position, { x: 2, y: 1 })]);
+      createEntity(world);
+      const entity4 = createEntity(world, [withValue(Position, { x: 1, y: 2 })]);
+
+      expect(getEntitiesWithValue(Position, { x: 1, y: 2 })).toEqual(new Set([entity1, entity4]));
+    });
+  });
+
+  describe("overridableComponent", () => {
+    it("should return a overridable component", () => {
+      const Position = defineComponent(world, { x: Type.Number, y: Type.Number });
+      const OverridablePosition = overridableComponent(Position);
+      expect("addOverride" in OverridablePosition).toBe(true);
+      expect("addOverride" in OverridablePosition).toBe(true);
+    });
+
+    it("should mirror all values of the source component", () => {
+      const Position = defineComponent(world, { x: Type.Number, y: Type.Number });
+      const entity1 = createEntity(world);
+      setComponent(Position, entity1, { x: 1, y: 2 });
+
+      const OverridablePosition = overridableComponent(Position);
+      expect(getComponentValue(OverridablePosition, entity1)).toEqual({ x: 1, y: 2 });
+    });
+
+    it("the overridable component should be updated if the original component is updated", () => {
+      const Position = defineComponent(world, { x: Type.Number, y: Type.Number });
+      const entity1 = createEntity(world);
+      setComponent(Position, entity1, { x: 1, y: 2 });
+
+      const OverridableComponent = overridableComponent(Position);
+
+      setComponent(Position, entity1, { x: 2, y: 2 });
+      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 2, y: 2 });
+
+      const entity2 = createEntity(world, [withValue(Position, { x: 3, y: 3 })]);
+      expect(getComponentValue(OverridableComponent, entity2)).toEqual({ x: 3, y: 3 });
+    });
+
+    it("should return the updated component value if there is a relevant update for the given entity", () => {
+      const Position = defineComponent(world, { x: Type.Number, y: Type.Number });
+      const entity1 = createEntity(world);
+      const entity2 = createEntity(world);
+      setComponent(Position, entity1, { x: 1, y: 2 });
+      setComponent(Position, entity2, { x: 5, y: 6 });
+
+      const OverridableComponent = overridableComponent(Position);
+      OverridableComponent.addOverride("firstOverride", { entity: entity1, value: { x: 2, y: 3 } });
+      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 2, y: 3 });
+      expect(getComponentValue(OverridableComponent, entity2)).toEqual({ x: 5, y: 6 });
+
+      OverridableComponent.addOverride("secondOverride", { entity: entity1, value: { x: 3, y: 3 } });
+      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 3, y: 3 });
+
+      OverridableComponent.removeOverride("secondOverride");
+      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 2, y: 3 });
+
+      setComponent(Position, entity1, { x: 10, y: 20 });
+      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 2, y: 3 });
+
+      OverridableComponent.removeOverride("firstOverride");
+      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 10, y: 20 });
+    });
+
+    it("adding an override should trigger reactions depending on the getComponentValue of the overriden component", () => {
+      const Position = defineComponent(world, { x: Type.Number, y: Type.Number });
+      const entity1 = createEntity(world);
+      setComponent(Position, entity1, { x: 1, y: 2 });
+
+      const OverridablePosition = overridableComponent(Position);
+
+      const spy = jest.fn();
+      OverridablePosition.update$.subscribe(spy);
+
+      expect(spy).toHaveBeenCalledTimes(0);
+
+      OverridablePosition.addOverride("firstOverride", { entity: entity1, value: { x: 3, y: 3 } });
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spy).toHaveBeenLastCalledWith({
+        entity: entity1,
+        component: OverridablePosition,
+        value: [
+          { x: 3, y: 3 },
+          { x: 1, y: 2 },
+        ],
+      });
+
+      OverridablePosition.removeOverride("firstOverride");
+      expect(spy).toHaveBeenCalledTimes(2);
+      expect(spy).toHaveBeenLastCalledWith({
+        entity: entity1,
+        component: OverridablePosition,
+        value: [
+          { x: 1, y: 2 },
+          { x: 3, y: 3 },
+        ],
+      });
+
+      OverridablePosition.addOverride("secondOverride", {
+        entity: "42" as Entity,
+        value: { x: 2, y: 3 },
+      });
+      expect(spy).toHaveBeenLastCalledWith({
+        entity: "42",
+        component: OverridablePosition,
+        value: [{ x: 2, y: 3 }, undefined],
+      });
+      expect(spy).toHaveBeenCalledTimes(3);
+    });
+  });
+});

package/src/Component.ts

@@ -19,7 +19,13 @@ import { isFullComponentValue, isIndexer } from "./utils";
 import { getEntityString, getEntitySymbol } from "./Entity";
 
 function getComponentName(component: Component<any, any, any>) {
-  return component.metadata?.tableId ?? component.metadata?.contractId ?? component.id;
+  return (
+    component.metadata?.componentName ??
+    component.metadata?.tableName ??
+    component.metadata?.tableId ??
+    component.metadata?.contractId ??
+    component.id
+  );
 }
 
 /**
@@ -31,7 +37,7 @@ function getComponentName(component: Component<any, any, any>) {
  * @param schema {@link Schema} of component values. Uses Type enum as bridge between typescript types and javascript accessible values.
  * @param options Optional: {
  *    id: descriptive id for this component (otherwise an autogenerated id is used),
- *    metadata: arbitrary metadata (eg. contractId for solecs mapped components),
+ *    metadata: arbitrary metadata,
  *    indexed: if this flag is set, an indexer is applied to this component (see {@link createIndexer})
  * }
  * @returns Component object linked to the provided World
@@ -41,7 +47,7 @@ function getComponentName(component: Component<any, any, any>) {
  * const Position = defineComponent(world, { x: Type.Number, y: Type.Number }, { id: "Position" });
  * ```
  */
-export function defineComponent<S extends Schema, M extends Metadata, T = undefined>(
+export function defineComponent<S extends Schema, M extends Metadata, T = unknown>(
   world: World,
   schema: S,
   options?: { id?: string; metadata?: M; indexed?: boolean }
@@ -71,7 +77,7 @@ export function defineComponent<S extends Schema, M extends Metadata, T = undefi
  * setComponent(Position, entity, { x: 1, y: 2 });
  * ```
  */
-export function setComponent<S extends Schema, T = undefined>(
+export function setComponent<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
   entity: Entity,
   value: ComponentValue<S, T>
@@ -122,7 +128,7 @@ export function setComponent<S extends Schema, T = undefined>(
  * updateComponent(Position, entity, { x: 1 });
  * ```
  */
-export function updateComponent<S extends Schema, T = undefined>(
+export function updateComponent<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
   entity: Entity,
   value: Partial<ComponentValue<S, T>>,
@@ -145,7 +151,7 @@ export function updateComponent<S extends Schema, T = undefined>(
  * @param component {@link defineComponent Component} to be updated.
  * @param entity {@link Entity} whose value should be removed from this component.
  */
-export function removeComponent<S extends Schema, M extends Metadata, T>(
+export function removeComponent<S extends Schema, M extends Metadata, T = unknown>(
   component: Component<S, M, T>,
   entity: Entity
 ) {
@@ -164,7 +170,7 @@ export function removeComponent<S extends Schema, M extends Metadata, T>(
  * @param entity {@link Entity} to check whether it has a value in the given component.
  * @returns true if the component contains a value for the given entity, else false.
  */
-export function hasComponent<S extends Schema, T = undefined>(
+export function hasComponent<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
   entity: Entity
 ): boolean {
@@ -181,7 +187,7 @@ export function hasComponent<S extends Schema, T = undefined>(
  * @param entity {@link Entity} to get the value for from the given component.
  * @returns Value of the given entity in the given component or undefined if no value exists.
  */
-export function getComponentValue<S extends Schema, T = undefined>(
+export function getComponentValue<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
   entity: Entity
 ): ComponentValue<S, T> | undefined {
@@ -210,7 +216,7 @@ export function getComponentValue<S extends Schema, T = undefined>(
  * @remarks
  * Throws an error if no value exists in the component for the given entity.
  */
-export function getComponentValueStrict<S extends Schema, T = undefined>(
+export function getComponentValueStrict<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
   entity: Entity
 ): ComponentValue<S, T> {
@@ -233,7 +239,7 @@ export function getComponentValueStrict<S extends Schema, T = undefined>(
  * componentValueEquals({ x: 1 }, { x: 1, y: 3 }) // returns true because x is equal and y is not present in a
  * ```
  */
-export function componentValueEquals<S extends Schema, T = undefined>(
+export function componentValueEquals<S extends Schema, T = unknown>(
   a?: Partial<ComponentValue<S, T>>,
   b?: ComponentValue<S, T>
 ): boolean {
@@ -256,7 +262,7 @@ export function componentValueEquals<S extends Schema, T = undefined>(
  * @param value {@link ComponentValue} with {@link ComponentSchema} `S`
  * @returns Tuple `[component, value]`
  */
-export function withValue<S extends Schema, T = undefined>(
+export function withValue<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
   value: ComponentValue<S, T>
 ): [Component<S, Metadata, T>, ComponentValue<S, T>] {
@@ -296,7 +302,7 @@ export function getEntitiesWithValue<S extends Schema>(
  * @param component {@link defineComponent Component} to get all entities from
  * @returns Set of all entities in the given component.
  */
-export function getComponentEntities<S extends Schema, T = undefined>(
+export function getComponentEntities<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>
 ): IterableIterator<Entity> {
   return component.entities();
@@ -316,7 +322,7 @@ export function getComponentEntities<S extends Schema, T = undefined>(
  * @param component {@link defineComponent Component} to use as underlying source for the overridable component
  * @returns overridable component
  */
-export function overridableComponent<S extends Schema, M extends Metadata, T = undefined>(
+export function overridableComponent<S extends Schema, M extends Metadata, T = unknown>(
   component: Component<S, M, T>
 ): OverridableComponent<S, M, T> {
   let nonce = 0;
@@ -455,7 +461,7 @@ export function clearLocalCache(component: Component, uniqueWorldIdentifier?: st
 }
 
 // Note: Only proof of concept for now - use this only for component that do not update frequently
-export function createLocalCache<S extends Schema, M extends Metadata, T = undefined>(
+export function createLocalCache<S extends Schema, M extends Metadata, T = unknown>(
   component: Component<S, M, T>,
   uniqueWorldIdentifier?: string
 ): Component<S, M, T> {

package/src/Entity.spec.ts

@@ -0,0 +1,45 @@
+import { defineComponent, getComponentValue, hasComponent, withValue } from "./Component";
+import { Type } from "./constants";
+import { createEntity } from "./Entity";
+import { World } from "./types";
+import { createWorld } from "./World";
+
+describe("Entity", () => {
+  let world: World;
+
+  beforeEach(() => {
+    world = createWorld();
+  });
+
+  describe("createEntity", () => {
+    it("should return a unique id", () => {
+      const firstEntity = createEntity(world);
+      const secondEntity = createEntity(world);
+      expect(firstEntity).not.toEqual(secondEntity);
+    });
+
+    it("should register the entity in the world", () => {
+      expect([...world.getEntities()].length).toEqual(0);
+      createEntity(world);
+      expect([...world.getEntities()].length).toEqual(1);
+    });
+
+    it("should create an entity with given components and values", () => {
+      const Position = defineComponent(world, { x: Type.Number, y: Type.Number });
+      const CanMove = defineComponent(world, { value: Type.Boolean });
+
+      const value1 = { x: 1, y: 1 };
+      const value2 = { x: 2, y: 1 };
+
+      const movableEntity = createEntity(world, [withValue(Position, value1), withValue(CanMove, { value: true })]);
+
+      const staticEntity = createEntity(world, [withValue(Position, value2)]);
+
+      expect(getComponentValue(Position, movableEntity)).toEqual(value1);
+      expect(hasComponent(CanMove, movableEntity)).toBe(true);
+
+      expect(getComponentValue(Position, staticEntity)).toEqual(value2);
+      expect(hasComponent(CanMove, staticEntity)).toBe(false);
+    });
+  });
+});

package/src/Entity.ts

@@ -8,7 +8,7 @@ import { Component, ComponentValue, Entity, EntitySymbol, World } from "./types"
  * @param components Array of [{@link defineComponent Component}, {@link ComponentValue}] tuples to be added to this entity.
  * (Use {@link withValue} to generate these tuples with type safety.)
  * @param options Optional: {
- *   id: {@link Entity} for this entity. Use this for entities that were created outside of recs, eg. in the corresponding solecs contracts.
+ *   id: {@link Entity} for this entity. Use this for entities that were created outside of recs.
  *   idSuffix: string to be appended to the auto-generated id. Use this for improved readability. Do not use this if the `id` option is provided.
  * }
  * @returns index of this entity in the {@link World}. This {@link Entity} is used to refer to this entity in other recs methods (eg {@link setComponent}).