@latticexyz/recs 2.0.12-main-d7526607 → 2.0.12-main-96e7bf43

package/src/System.ts

@@ -1,150 +0,0 @@
-import { concat, EMPTY, from, Observable } from "rxjs";
-import { getComponentEntities, removeComponent, setComponent } from "./Component";
-import { UpdateType } from "./constants";
-import { defineEnterQuery, defineExitQuery, defineQuery, defineUpdateQuery } from "./Query";
-import { Component, ComponentUpdate, ComponentValue, Entity, QueryFragment, Schema, World } from "./types";
-import { toUpdateStream } from "./utils";
-
-/**
- * Create a system that is called on every update of the given observable.
- *
- * @remarks
- * Advantage of using this function over directly subscribing to the RxJS observable is that the system is registered in the `world` and
- * disposed when the `world` is disposed (eg. during a hot reload in development).
- *
- * @param world {@link World} object this system should be registered in.
- * @param observable$ Observable to react to.
- * @param system System function to run on updates of the `observable$`. System function gets passed the update events from the `observable$`.
- */
-export function defineRxSystem<T>(world: World, observable$: Observable<T>, system: (event: T) => void) {
-  const subscription = observable$.subscribe(system);
-  world.registerDisposer(() => subscription?.unsubscribe());
-}
-
-/**
- * Create a system that is called on every event of the given {@link defineUpdateQuery update query}.
- *
- * @param world {@link World} object this system should be registered in.
- * @param query Update query to react to.
- * @param system System function to run when the result of the given update query changes.
- * @param options Optional: {
- * runOnInit: if true, run this system for all entities matching the query when the system is created.
- * Else only run on updates after the system is created. Default true.
- * }
- */
-export function defineUpdateSystem(
-  world: World,
-  query: QueryFragment[],
-  system: (update: ComponentUpdate) => void,
-  options: { runOnInit?: boolean } = { runOnInit: true },
-) {
-  defineRxSystem(world, defineUpdateQuery(query, options), system);
-}
-
-/**
- * Create a system that is called on every event of the given {@link defineEnterQuery enter query}.
- *
- * @param world {@link World} object this system should be registered in.
- * @param query Enter query to react to.
- * @param system System function to run when the result of the given enter query changes.
- * @param options Optional: {
- * runOnInit: if true, run this system for all entities matching the query when the system is created.
- * Else only run on updates after the system is created. Default true.
- * }
- */
-export function defineEnterSystem(
-  world: World,
-  query: QueryFragment[],
-  system: (update: ComponentUpdate) => void,
-  options: { runOnInit?: boolean } = { runOnInit: true },
-) {
-  defineRxSystem(world, defineEnterQuery(query, options), system);
-}
-
-/**
- * Create a system that is called on every event of the given {@link defineExitQuery exit query}.
- *
- * @param world {@link World} object this system should be registered in.
- * @param query Exit query to react to.
- * @param system System function to run when the result of the given exit query changes.
- * @param options Optional: {
- * runOnInit: if true, run this system for all entities matching the query when the system is created.
- * Else only run on updates after the system is created. Default true.
- * }
- */
-export function defineExitSystem(
-  world: World,
-  query: QueryFragment[],
-  system: (update: ComponentUpdate) => void,
-  options: { runOnInit?: boolean } = { runOnInit: true },
-) {
-  defineRxSystem(world, defineExitQuery(query, options), system);
-}
-
-/**
- * Create a system that is called on every event of the given {@link defineQuery query}.
- *
- * @param world {@link World} object this system should be registered in.
- * @param query Query to react to.
- * @param system System function to run when the result of the given query changes.
- * @param options Optional: {
- * runOnInit: if true, run this system for all entities matching the query when the system is created.
- * Else only run on updates after the system is created. Default true.
- * }
- */
-export function defineSystem(
-  world: World,
-  query: QueryFragment[],
-  system: (update: ComponentUpdate & { type: UpdateType }) => void,
-  options: { runOnInit?: boolean } = { runOnInit: true },
-) {
-  defineRxSystem(world, defineQuery(query, options).update$, system);
-}
-
-/**
- * Create a system that is called every time the given component is updated.
- *
- * @param world {@link World} object this system should be registered in.
- * @param component Component to whose updates to react.
- * @param system System function to run when the given component is updated.
- * @param options Optional: {
- * runOnInit: if true, run this system for all entities in the component when the system is created.
- * Else only run on updates after the system is created. Default true.
- * }
- */
-export function defineComponentSystem<S extends Schema>(
-  world: World,
-  component: Component<S>,
-  system: (update: ComponentUpdate<S>) => void,
-  options: { runOnInit?: boolean } = { runOnInit: true },
-) {
-  const initial$ = options?.runOnInit ? from(getComponentEntities(component)).pipe(toUpdateStream(component)) : EMPTY;
-  defineRxSystem(world, concat(initial$, component.update$), system);
-}
-
-/**
- * Create a system to synchronize updates to one component with another component.
- *
- * @param world {@link World} object this system should be registered in.
- * @param query Result of `component` is added to all entites matching this query.
- * @param component Function returning the component to be added to all entities matching the given query.
- * @param value Function returning the component value to be added to all entities matching the given query.
- */
-export function defineSyncSystem<T extends Schema>(
-  world: World,
-  query: QueryFragment[],
-  component: (entity: Entity) => Component<T>,
-  value: (entity: Entity) => ComponentValue<T>,
-  options: { update?: boolean; runOnInit?: boolean } = { update: false, runOnInit: true },
-) {
-  defineSystem(
-    world,
-    query,
-    ({ entity, type }) => {
-      if (type === UpdateType.Enter) setComponent(component(entity), entity, value(entity));
-      if (type === UpdateType.Exit) removeComponent(component(entity), entity);
-      if (options?.update && type === UpdateType.Update) setComponent(component(entity), entity, value(entity));
-    },
-    options,
-  );
-}

package/src/World.spec.ts

@@ -1,79 +0,0 @@
-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/World.ts

@@ -1,102 +0,0 @@
-import { transformIterator } from "@latticexyz/utils";
-import { hasComponent, removeComponent } from "./Component";
-import { getEntityString, getEntitySymbol } from "./Entity";
-import { Component, Entity, EntitySymbol, World } from "./types";
-
-/**
- * Create a new World.
- *
- * @remarks
- * A World is the central object of an ECS application, where all {@link defineComponent Components},
- * {@link registerEntity Entities} and {@link defineSystem Systems} are registerd.
- *
- * @returns A new World
- */
-export function createWorld() {
-  const entitySymbols = new Set<EntitySymbol>();
-  const components: Component[] = [];
-  let disposers: [string, () => void][] = [];
-
-  function registerEntity({ id, idSuffix }: { id?: string; idSuffix?: string } = {}) {
-    const entity = (id || entitySymbols.size + (idSuffix ? "-" + idSuffix : "")) as Entity;
-    const entitySymbol = getEntitySymbol(entity);
-
-    // Register entity
-    entitySymbols.add(entitySymbol);
-
-    return entity;
-  }
-
-  function getEntities() {
-    return transformIterator(entitySymbols.values(), getEntityString);
-  }
-
-  function registerComponent(component: Component) {
-    components.push(component);
-  }
-
-  function dispose(namespace?: string) {
-    for (const [, disposer] of disposers.filter((d) => !namespace || d[0] === namespace)) {
-      disposer();
-    }
-    disposers = disposers.filter((d) => namespace && d[0] !== namespace);
-  }
-
-  function registerDisposer(disposer: () => void, namespace = "") {
-    disposers.push([namespace, disposer]);
-  }
-
-  function hasEntity(entity: Entity): boolean {
-    const entitySymbol = getEntitySymbol(entity);
-    return entitySymbols.has(entitySymbol);
-  }
-
-  function deleteEntity(entity: Entity) {
-    for (const component of components) {
-      if (hasComponent(component, entity)) removeComponent(component, entity);
-    }
-    entitySymbols.delete(getEntitySymbol(entity));
-  }
-
-  return {
-    registerEntity,
-    components,
-    registerComponent,
-    dispose,
-    registerDisposer,
-    hasEntity,
-    getEntities,
-    entitySymbols,
-    deleteEntity,
-  } satisfies World;
-}
-
-/**
- * Create a new namespace from an existing World.
- * The `dispose` method of a namespaced World only calls disposers registered on this namespace.
- *
- * @param world World to create a new namespace for.
- * @param namespace String descriptor of the new namespace.
- * @returns World with a new namespace.
- */
-export function namespaceWorld(world: ReturnType<typeof createWorld>, namespace: string) {
-  return {
-    ...world,
-    registerDisposer: (disposer: () => void) => world.registerDisposer(disposer, namespace),
-    dispose: () => world.dispose(namespace),
-  };
-}
-
-/**
- * Get all components that have a value for the given entity.
- *
- * @dev Design decision: don't store a list of components for each entity but compute it dynamically when needed
- * because there are less components than entities and maintaining a list of components per entity is a large overhead.
- *
- * @param world World object the given entity is registered on.
- * @param entity {@link Entity} to get the list of components for.
- * @returns Array of components that have a value for the given entity.
- */
-export function getEntityComponents(world: World, entity: Entity): Component[] {
-  return world.components.filter((component) => hasComponent(component, entity));
-}

package/src/constants.ts

@@ -1,54 +0,0 @@
-/**
- * Type enum is used to specify value types in {@link ComponentSchema} to be able
- * to access type values in JavaScript in addition to TypeScript type checks.
- */
-export enum Type {
-  Boolean,
-  Number,
-  OptionalNumber,
-  BigInt,
-  OptionalBigInt,
-  String,
-  OptionalString,
-  NumberArray,
-  OptionalNumberArray,
-  BigIntArray,
-  OptionalBigIntArray,
-  StringArray,
-  OptionalStringArray,
-  Entity,
-  OptionalEntity,
-  EntityArray,
-  OptionalEntityArray,
-  T,
-  OptionalT,
-}
-
-/**
- * Used to specify type of {@link ComponentUpdate}.
- * - Enter: Update added a value to an entity that did not have a value before
- * - Exit: Update removed a value from an entity that had a value before
- * - Update: Update changed a value of an entity that already had a value before. Note: the value doesn't need to be different from the previous value.
- * - Noop: Update did nothing (removed a value from an entity that did not have a value)
- */
-export enum UpdateType {
-  Enter,
-  Exit,
-  Update,
-  Noop,
-}
-
-/**
- * Helper constant with all optional {@link Type}s.
- */
-export const OptionalTypes = [
-  Type.OptionalEntity,
-  Type.OptionalEntityArray,
-  Type.OptionalNumber,
-  Type.OptionalNumberArray,
-  Type.OptionalBigInt,
-  Type.OptionalBigIntArray,
-  Type.OptionalString,
-  Type.OptionalStringArray,
-  Type.OptionalT,
-];

package/src/deprecated/constants.ts

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