@latticexyz/recs 2.0.0-snapshot-test-32d38619 → 2.0.0

package/src/Component.ts

@@ -18,6 +18,12 @@ import {
 import { isFullComponentValue, isIndexer } from "./utils";
 import { getEntityString, getEntitySymbol } from "./Entity";
 
+export type ComponentMutationOptions = {
+  /** Skip publishing this mutation to the component's update stream. Mostly used internally during initial hydration. */
+  skipUpdateStream?: boolean;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function getComponentName(component: Component<any, any, any>) {
   return (
     component.metadata?.componentName ??
@@ -50,7 +56,7 @@ function getComponentName(component: Component<any, any, any>) {
 export function defineComponent<S extends Schema, M extends Metadata, T = unknown>(
   world: World,
   schema: S,
-  options?: { id?: string; metadata?: M; indexed?: boolean }
+  options?: { id?: string; metadata?: M; indexed?: boolean },
 ) {
   if (Object.keys(schema).length === 0) throw new Error("Component schema must have at least one key");
   const id = options?.id ?? uuid();
@@ -80,7 +86,8 @@ export function defineComponent<S extends Schema, M extends Metadata, T = unknow
 export function setComponent<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
   entity: Entity,
-  value: ComponentValue<S, T>
+  value: ComponentValue<S, T>,
+  options: ComponentMutationOptions = {},
 ) {
   const entitySymbol = getEntitySymbol(entity);
   const prevValue = getComponentValue(component, entity);
@@ -104,12 +111,14 @@ export function setComponent<S extends Schema, T = unknown>(
           "for entity",
           entity,
           ". Existing keys: ",
-          Object.keys(component.values)
+          Object.keys(component.values),
         );
       }
     }
   }
-  component.update$.next({ entity, value: [value, prevValue], component });
+  if (!options.skipUpdateStream) {
+    component.update$.next({ entity, value: [value, prevValue], component });
+  }
 }
 
 /**
@@ -132,16 +141,17 @@ export function updateComponent<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
   entity: Entity,
   value: Partial<ComponentValue<S, T>>,
-  initialValue?: ComponentValue<S, T>
+  initialValue?: ComponentValue<S, T>,
+  options: ComponentMutationOptions = {},
 ) {
   const currentValue = getComponentValue(component, entity);
   if (currentValue === undefined) {
     if (initialValue === undefined) {
       throw new Error(`Can't update component ${getComponentName(component)} without a current value or initial value`);
     }
-    setComponent(component, entity, { ...initialValue, ...value });
+    setComponent(component, entity, { ...initialValue, ...value }, options);
   } else {
-    setComponent(component, entity, { ...currentValue, ...value });
+    setComponent(component, entity, { ...currentValue, ...value }, options);
   }
 }
 
@@ -153,14 +163,17 @@ export function updateComponent<S extends Schema, T = unknown>(
  */
 export function removeComponent<S extends Schema, M extends Metadata, T = unknown>(
   component: Component<S, M, T>,
-  entity: Entity
+  entity: Entity,
+  options: ComponentMutationOptions = {},
 ) {
   const entitySymbol = getEntitySymbol(entity);
   const prevValue = getComponentValue(component, entity);
   for (const key of Object.keys(component.values)) {
     component.values[key].delete(entitySymbol);
   }
-  component.update$.next({ entity, value: [undefined, prevValue], component });
+  if (!options.skipUpdateStream) {
+    component.update$.next({ entity, value: [undefined, prevValue], component });
+  }
 }
 
 /**
@@ -172,7 +185,7 @@ export function removeComponent<S extends Schema, M extends Metadata, T = unknow
  */
 export function hasComponent<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
-  entity: Entity
+  entity: Entity,
 ): boolean {
   const entitySymbol = getEntitySymbol(entity);
   const map = Object.values(component.values)[0];
@@ -189,7 +202,7 @@ export function hasComponent<S extends Schema, T = unknown>(
  */
 export function getComponentValue<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
-  entity: Entity
+  entity: Entity,
 ): ComponentValue<S, T> | undefined {
   const value: Record<string, unknown> = {};
   const entitySymbol = getEntitySymbol(entity);
@@ -218,7 +231,7 @@ export function getComponentValue<S extends Schema, T = unknown>(
  */
 export function getComponentValueStrict<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
-  entity: Entity
+  entity: Entity,
 ): ComponentValue<S, T> {
   const value = getComponentValue(component, entity);
   if (!value) throw new Error(`No value for component ${getComponentName(component)} on entity ${entity}`);
@@ -241,7 +254,7 @@ export function getComponentValueStrict<S extends Schema, T = unknown>(
  */
 export function componentValueEquals<S extends Schema, T = unknown>(
   a?: Partial<ComponentValue<S, T>>,
-  b?: ComponentValue<S, T>
+  b?: ComponentValue<S, T>,
 ): boolean {
   if (!a && !b) return true;
   if (!a || !b) return false;
@@ -264,7 +277,7 @@ export function componentValueEquals<S extends Schema, T = unknown>(
  */
 export function withValue<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
-  value: ComponentValue<S, T>
+  value: ComponentValue<S, T>,
 ): [Component<S, Metadata, T>, ComponentValue<S, T>] {
   return [component, value];
 }
@@ -278,7 +291,7 @@ export function withValue<S extends Schema, T = unknown>(
  */
 export function getEntitiesWithValue<S extends Schema>(
   component: Component<S> | Indexer<S>,
-  value: Partial<ComponentValue<S>>
+  value: Partial<ComponentValue<S>>,
 ): Set<Entity> {
   // Shortcut for indexers
   if (isIndexer(component) && isFullComponentValue(component, value)) {
@@ -303,7 +316,7 @@ export function getEntitiesWithValue<S extends Schema>(
  * @returns Set of all entities in the given component.
  */
 export function getComponentEntities<S extends Schema, T = unknown>(
-  component: Component<S, Metadata, T>
+  component: Component<S, Metadata, T>,
 ): IterableIterator<Entity> {
   return component.entities();
 }
@@ -323,7 +336,7 @@ export function getComponentEntities<S extends Schema, T = unknown>(
  * @returns overridable component
  */
 export function overridableComponent<S extends Schema, M extends Metadata, T = unknown>(
-  component: Component<S, M, T>
+  component: Component<S, M, T>,
 ): OverridableComponent<S, M, T> {
   let nonce = 0;
 
@@ -445,7 +458,7 @@ export function overridableComponent<S extends Schema, M extends Metadata, T = u
   component.update$
     .pipe(
       filter((e) => !overriddenEntityValues.get(getEntitySymbol(e.entity))),
-      map((update) => ({ ...update, component: overriddenComponent }))
+      map((update) => ({ ...update, component: overriddenComponent })),
     )
     .subscribe(update$);
 
@@ -463,7 +476,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 = unknown>(
   component: Component<S, M, T>,
-  uniqueWorldIdentifier?: string
+  uniqueWorldIdentifier?: string,
 ): Component<S, M, T> {
   const { world, update$, values } = component;
   const cacheId = getLocalCacheId(component as Component, uniqueWorldIdentifier);
@@ -497,7 +510,7 @@ export function createLocalCache<S extends Schema, M extends Metadata, T = unkno
   const updateSub = update$.subscribe(() => {
     numUpdates++;
     const encoded = JSON.stringify(
-      Object.entries(mapObject(values, (m) => [...m.entries()].map((e) => [getEntityString(e[0]), e[1]])))
+      Object.entries(mapObject(values, (m) => [...m.entries()].map((e) => [getEntityString(e[0]), e[1]]))),
     );
     localStorage.setItem(cacheId, encoded);
     if (numUpdates > 200) {
@@ -508,7 +521,7 @@ export function createLocalCache<S extends Schema, M extends Metadata, T = unkno
         numUpdates,
         "times since",
         new Date(creation).toLocaleTimeString(),
-        "- the local cache is in an alpha state and should not be used with components that update frequently yet"
+        "- the local cache is in an alpha state and should not be used with components that update frequently yet",
       );
     }
   });

package/src/Entity.ts

@@ -17,7 +17,7 @@ import { Component, ComponentValue, Entity, EntitySymbol, World } from "./types"
 export function createEntity(
   world: World,
   components?: [Component, ComponentValue][],
-  options?: { id?: string } | { idSuffix?: string }
+  options?: { id?: string } | { idSuffix?: string },
 ): Entity {
   const entity = world.registerEntity(options ?? {});
 

package/src/Indexer.ts

@@ -7,7 +7,8 @@ import { Component, ComponentValue, Entity, EntitySymbol, Indexer, Metadata, Sch
  *
  * @remarks
  * An indexed component keeps a "reverse mapping" from {@link ComponentValue} to the Set of {@link createEntity Entities} with this value.
- * This adds a performance overhead to modifying component values and a memory overhead since in the worst case there is one Set per entity (if every entity has a different component value).
+ * This adds a performance overhead to modifying component values and a memory overhead since in the worst case there is one
+ * Set per entity (if every entity has a different component value).
  * In return the performance for querying for entities with a given component value is close to O(1) (instead of O(#entities) in a regular non-indexed component).
  * As a rule of thumb only components that are added to many entities and are queried with {@link HasValue} a lot should be indexed (eg. the Position component).
  *
@@ -17,7 +18,7 @@ import { Component, ComponentValue, Entity, EntitySymbol, Indexer, Metadata, Sch
  * @returns Indexed version of the component.
  */
 export function createIndexer<S extends Schema, M extends Metadata, T = unknown>(
-  component: Component<S, M, T>
+  component: Component<S, M, T>,
 ): Indexer<S, M, T> {
   const valueToEntities = new Map<string, Set<EntitySymbol>>();
 

package/src/Performance.spec.ts

@@ -35,6 +35,7 @@ describe("V2", () => {
     const Position = defineComponentV2(world, { x: TypeV2.Number, y: TypeV2.Number });
 
     defineSystem(world, [HasValueV2(Position, { x: 1, y: 1 })], (update) => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const e = update;
     });
 

package/src/Query.spec.ts

@@ -98,27 +98,27 @@ describe("Query", () => {
       expect(runQuery([HasValue(OwnedByEntity, { value: Player })])).toEqual(new Set([Depth1]));
 
       expect(runQuery([ProxyExpand(OwnedByEntity, 0), HasValue(OwnedByEntity, { value: Player })])).toEqual(
-        new Set([Depth1])
+        new Set([Depth1]),
       );
 
       expect(runQuery([ProxyExpand(OwnedByEntity, 1), HasValue(OwnedByEntity, { value: Player })])).toEqual(
-        new Set([Depth1, Depth2])
+        new Set([Depth1, Depth2]),
       );
 
       expect(runQuery([ProxyExpand(OwnedByEntity, 2), HasValue(OwnedByEntity, { value: Player })])).toEqual(
-        new Set([Depth1, Depth2, Depth3])
+        new Set([Depth1, Depth2, Depth3]),
       );
 
       expect(runQuery([ProxyExpand(OwnedByEntity, 3), HasValue(OwnedByEntity, { value: Player })])).toEqual(
-        new Set([Depth1, Depth2, Depth3, Depth4])
+        new Set([Depth1, Depth2, Depth3, Depth4]),
       );
 
       expect(runQuery([ProxyExpand(OwnedByEntity, 4), HasValue(OwnedByEntity, { value: Player })])).toEqual(
-        new Set([Depth1, Depth2, Depth3, Depth4, Depth5])
+        new Set([Depth1, Depth2, Depth3, Depth4, Depth5]),
       );
 
       expect(
-        runQuery([ProxyExpand(OwnedByEntity, Number.MAX_SAFE_INTEGER), HasValue(OwnedByEntity, { value: Player })])
+        runQuery([ProxyExpand(OwnedByEntity, Number.MAX_SAFE_INTEGER), HasValue(OwnedByEntity, { value: Player })]),
       ).toEqual(new Set([Depth1, Depth2, Depth3, Depth4, Depth5]));
     });
 
@@ -132,8 +132,8 @@ describe("Query", () => {
       expect(
         runQuery(
           [ProxyRead(OwnedByEntity, 1), HasValue(Name, { name: "Alice" })],
-          new Set([Depth1, Depth2, Depth3]) // Provide an initial set of entities
-        )
+          new Set([Depth1, Depth2, Depth3]), // Provide an initial set of entities
+        ),
       ).toEqual(new Set([Depth1]));
 
       expect(
@@ -142,7 +142,7 @@ describe("Query", () => {
           HasValue(Name, { name: "Alice" }), // Get all entities with name Alice or owned by Alice
           ProxyExpand(OwnedByEntity, 0), // Turn off proxy expand
           NotValue(Name, { name: "Alice" }), // Filter Alice, only keep entities owned by Alice
-        ])
+        ]),
       ).toEqual(new Set([Depth1]));
 
       expect(
@@ -151,15 +151,15 @@ describe("Query", () => {
           HasValue(Name, { name: "Alice" }), // Get all child entities of Alice (including alice)
           ProxyExpand(OwnedByEntity, 0), // Turn off proxy expand
           NotValue(Name, { name: "Alice" }), // Filter Alice, only keep entities owned by Alice
-        ])
+        ]),
       ).toEqual(new Set([Depth1, Depth2, Depth3, Depth4]));
 
       // Get all entities from the initial set [Depth3] that have an indirect owner called Alice
       expect(
         runQuery(
           [ProxyRead(OwnedByEntity, Number.MAX_SAFE_INTEGER), HasValue(Name, { name: "Alice" })],
-          new Set([Depth3]) // Provide an initial set of entities
-        )
+          new Set([Depth3]), // Provide an initial set of entities
+        ),
       ).toEqual(new Set([Depth3]));
 
       // Get all entities that have an indirect owner called Alice
@@ -171,8 +171,8 @@ describe("Query", () => {
             ProxyRead(OwnedByEntity, 0),
             NotValue(Name, { name: "Alice" }),
           ],
-          new Set([Player, Depth1, Depth2, Depth3, Depth4]) // Provide an initial set of entities
-        )
+          new Set([Player, Depth1, Depth2, Depth3, Depth4]), // Provide an initial set of entities
+        ),
       ).toEqual(new Set([Depth1, Depth2, Depth3, Depth4]));
 
       // Get all entities from the initial set [Depth3] that have an indirect owner called Alice and their direct child
@@ -183,8 +183,8 @@ describe("Query", () => {
             ProxyExpand(OwnedByEntity, 1),
             HasValue(Name, { name: "Alice" }),
           ],
-          new Set([Depth2]) // Provide an initial set of entities
-        )
+          new Set([Depth2]), // Provide an initial set of entities
+        ),
       ).toEqual(new Set([Depth2, Depth3]));
     });
 
@@ -204,15 +204,15 @@ describe("Query", () => {
       createEntity(world, [withValue(Position, { x: 1, y: 1 })]);
 
       expect(runQuery([ProxyExpand(FromPrototype, 1), Has(CanMove), Not(Prototype)])).toEqual(
-        new Set([instance1, instance2])
+        new Set([instance1, instance2]),
       );
 
       expect(runQuery([Has(Position), ProxyRead(FromPrototype, 1), Has(CanMove)])).toEqual(
-        new Set([instance1, instance2])
+        new Set([instance1, instance2]),
       );
 
       expect(runQuery([ProxyRead(FromPrototype, 1), Has(Position), Has(CanMove)])).toEqual(
-        new Set([instance1, instance2])
+        new Set([instance1, instance2]),
       );
     });
 
@@ -287,7 +287,7 @@ describe("Query", () => {
           Has(CanMove), // ...have the CanMove component...
           ProxyRead(OwnedByEntity, Number.MAX_SAFE_INTEGER), // ...and for whose owner holds...
           NotValue(Name, { name: "Alice" }), // ...their name is not Alice
-        ])
+        ]),
       ).toEqual(new Set([Instance3, Entity8]));
     });
 
@@ -343,14 +343,14 @@ describe("Query", () => {
           entity: entities[0],
           component: CanMove,
           value: [{ value: true }, undefined],
-        })
+        }),
       );
       expect(mock).toHaveBeenCalledWith(
         expect.objectContaining({
           entity: entities[1],
           component: CanMove,
           value: [{ value: true }, undefined],
-        })
+        }),
       );
       expect(mock).toBeCalledTimes(2);
 
@@ -360,7 +360,7 @@ describe("Query", () => {
           entity: entities[2],
           component: CanMove,
           value: [{ value: true }, undefined],
-        })
+        }),
       );
       expect(mock).toHaveBeenCalledTimes(3);
     });
@@ -388,7 +388,7 @@ describe("Query", () => {
           entity: entity1,
           component: CanMove,
           value: [undefined, { value: true }],
-        })
+        }),
       );
 
       removeComponent(CanMove, entity2);
@@ -398,7 +398,7 @@ describe("Query", () => {
           entity: entity2,
           component: CanMove,
           value: [undefined, { value: true }],
-        })
+        }),
       );
     });
   });
@@ -617,7 +617,7 @@ describe("Query", () => {
 
       const query1 = defineQuery(
         [ProxyRead(OwnedByEntity, 1), HasValue(Name, { name: "Alice" })],
-        { initialSet: new Set([Depth1, Depth2, Depth3]) } // Provide an initial set of entities
+        { initialSet: new Set([Depth1, Depth2, Depth3]) }, // Provide an initial set of entities
       );
       query1.update$.subscribe();
 
@@ -639,7 +639,7 @@ describe("Query", () => {
 
       const query4 = defineQuery(
         [ProxyRead(OwnedByEntity, Number.MAX_SAFE_INTEGER), HasValue(Name, { name: "Alice" })],
-        { initialSet: new Set([Depth3]) } // Provide an initial set of entities
+        { initialSet: new Set([Depth3]) }, // Provide an initial set of entities
       );
       query4.update$.subscribe();
 
@@ -650,7 +650,7 @@ describe("Query", () => {
           ProxyRead(OwnedByEntity, 0),
           NotValue(Name, { name: "Alice" }),
         ],
-        { initialSet: new Set([Player, Depth1, Depth2, Depth3, Depth4]) } // Provide an initial set of entities
+        { initialSet: new Set([Player, Depth1, Depth2, Depth3, Depth4]) }, // Provide an initial set of entities
       );
       query5.update$.subscribe();
 
@@ -660,7 +660,7 @@ describe("Query", () => {
           ProxyExpand(OwnedByEntity, 1),
           HasValue(Name, { name: "Alice" }),
         ],
-        { initialSet: new Set([Depth2]) } // Provide an initial set of entities
+        { initialSet: new Set([Depth2]) }, // Provide an initial set of entities
       );
       query6.update$.subscribe();
 

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, share, Subject } from "rxjs";
+import { concat, concatMap, filter, from, map, merge, Observable, of, share } from "rxjs";
 import {
   componentValueEquals,
   getComponentEntities,
@@ -15,7 +15,6 @@ import {
   ComponentValue,
   Entity,
   EntityQueryFragment,
-  EntitySymbol,
   HasQueryFragment,
   HasValueQueryFragment,
   NotQueryFragment,
@@ -88,7 +87,7 @@ export function Not<T extends Schema>(component: Component<T>): NotQueryFragment
  */
 export function HasValue<T extends Schema>(
   component: Component<T>,
-  value: Partial<ComponentValue<T>>
+  value: Partial<ComponentValue<T>>,
 ): HasValueQueryFragment<T> {
   return { type: QueryFragmentType.HasValue, component, value };
 }
@@ -112,7 +111,7 @@ export function HasValue<T extends Schema>(
  */
 export function NotValue<T extends Schema>(
   component: Component<T>,
-  value: Partial<ComponentValue<T>>
+  value: Partial<ComponentValue<T>>,
 ): NotValueQueryFragment<T> {
   return { type: QueryFragmentType.NotValue, component, value };
 }
@@ -199,7 +198,7 @@ function passesQueryFragment<T extends Schema>(entity: Entity, fragment: EntityQ
  * @returns True if the query fragment is positive, else false.
  */
 function isPositiveFragment<T extends Schema>(
-  fragment: QueryFragment<T>
+  fragment: QueryFragment<T>,
 ): fragment is HasQueryFragment<T> | HasValueQueryFragment<T> {
   return fragment.type === QueryFragmentType.Has || fragment.type == QueryFragmentType.HasValue;
 }
@@ -211,7 +210,7 @@ function isPositiveFragment<T extends Schema>(
  * @returns True if the query fragment is negative, else false.
  */
 function isNegativeFragment<T extends Schema>(
-  fragment: QueryFragment<T>
+  fragment: QueryFragment<T>,
 ): fragment is NotQueryFragment<T> | NotValueQueryFragment<T> {
   return fragment.type === QueryFragmentType.Not || fragment.type == QueryFragmentType.NotValue;
 }
@@ -253,7 +252,7 @@ function isBreakingPassState(passes: boolean, fragment: EntityQueryFragment<Sche
 function passesQueryFragmentProxy<T extends Schema>(
   entity: Entity,
   fragment: EntityQueryFragment<T>,
-  proxyRead: ProxyReadQueryFragment
+  proxyRead: ProxyReadQueryFragment,
 ): boolean | null {
   let proxyEntity = entity;
   let passes = false;
@@ -288,7 +287,7 @@ function passesQueryFragmentProxy<T extends Schema>(
 export function getChildEntities(
   entity: Entity,
   component: Component<{ value: Type.Entity }>,
-  depth: number
+  depth: number,
 ): Set<Entity> {
   if (depth === 0) return new Set();
 
@@ -416,7 +415,7 @@ export function runQuery(fragments: QueryFragment[], initialSet?: Set<Entity>):
  */
 export function defineQuery(
   fragments: QueryFragment[],
-  options?: { runOnInit?: boolean; initialSet?: Set<Entity> }
+  options?: { runOnInit?: boolean; initialSet?: Set<Entity> },
 ): {
   update$: Observable<ComponentUpdate & { type: UpdateType }>;
   matching: ObservableSet<Entity>;
@@ -503,7 +502,7 @@ export function defineQuery(
               return { ...update, type: UpdateType.Enter };
             }
           }),
-      filterNullish()
+      filterNullish(),
     );
 
   return {
@@ -521,7 +520,7 @@ export function defineQuery(
  */
 export function defineUpdateQuery(
   fragments: QueryFragment[],
-  options?: { runOnInit?: boolean }
+  options?: { runOnInit?: boolean },
 ): Observable<ComponentUpdate & { type: UpdateType }> {
   return defineQuery(fragments, options).update$.pipe(filter((e) => e.type === UpdateType.Update));
 }
@@ -535,7 +534,7 @@ export function defineUpdateQuery(
  */
 export function defineEnterQuery(
   fragments: QueryFragment[],
-  options?: { runOnInit?: boolean }
+  options?: { runOnInit?: boolean },
 ): Observable<ComponentUpdate> {
   return defineQuery(fragments, options).update$.pipe(filter((e) => e.type === UpdateType.Enter));
 }
@@ -549,7 +548,7 @@ export function defineEnterQuery(
  */
 export function defineExitQuery(
   fragments: QueryFragment[],
-  options?: { runOnInit?: boolean }
+  options?: { runOnInit?: boolean },
 ): Observable<ComponentUpdate> {
   return defineQuery(fragments, options).update$.pipe(filter((e) => e.type === UpdateType.Exit));
 }

package/src/System.spec.ts

@@ -100,13 +100,13 @@ describe("System", () => {
 
       expect(mock).toHaveBeenCalledTimes(1);
       expect(mock).toHaveBeenCalledWith(
-        expect.objectContaining({ entity: entity1, component: CanMove, value: [{ value: true }, undefined] })
+        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] })
+        expect.objectContaining({ entity: entity2, component: CanMove, value: [{ value: true }, undefined] }),
       );
     });
 
@@ -126,13 +126,13 @@ describe("System", () => {
 
       expect(mock).toHaveBeenCalledTimes(1);
       expect(mock).toHaveBeenCalledWith(
-        expect.objectContaining({ entity: entity1, component: CanMove, value: [undefined, { value: true }] })
+        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 }] })
+        expect.objectContaining({ entity: entity2, component: CanMove, value: [undefined, { value: true }] }),
       );
     });
   });

package/src/System.ts

@@ -36,7 +36,7 @@ export function defineUpdateSystem(
   world: World,
   query: QueryFragment[],
   system: (update: ComponentUpdate) => void,
-  options: { runOnInit?: boolean } = { runOnInit: true }
+  options: { runOnInit?: boolean } = { runOnInit: true },
 ) {
   defineRxSystem(world, defineUpdateQuery(query, options), system);
 }
@@ -56,7 +56,7 @@ export function defineEnterSystem(
   world: World,
   query: QueryFragment[],
   system: (update: ComponentUpdate) => void,
-  options: { runOnInit?: boolean } = { runOnInit: true }
+  options: { runOnInit?: boolean } = { runOnInit: true },
 ) {
   defineRxSystem(world, defineEnterQuery(query, options), system);
 }
@@ -76,7 +76,7 @@ export function defineExitSystem(
   world: World,
   query: QueryFragment[],
   system: (update: ComponentUpdate) => void,
-  options: { runOnInit?: boolean } = { runOnInit: true }
+  options: { runOnInit?: boolean } = { runOnInit: true },
 ) {
   defineRxSystem(world, defineExitQuery(query, options), system);
 }
@@ -96,7 +96,7 @@ export function defineSystem(
   world: World,
   query: QueryFragment[],
   system: (update: ComponentUpdate & { type: UpdateType }) => void,
-  options: { runOnInit?: boolean } = { runOnInit: true }
+  options: { runOnInit?: boolean } = { runOnInit: true },
 ) {
   defineRxSystem(world, defineQuery(query, options).update$, system);
 }
@@ -116,7 +116,7 @@ export function defineComponentSystem<S extends Schema>(
   world: World,
   component: Component<S>,
   system: (update: ComponentUpdate<S>) => void,
-  options: { runOnInit?: boolean } = { runOnInit: true }
+  options: { runOnInit?: boolean } = { runOnInit: true },
 ) {
   const initial$ = options?.runOnInit ? from(getComponentEntities(component)).pipe(toUpdateStream(component)) : EMPTY;
   defineRxSystem(world, concat(initial$, component.update$), system);
@@ -135,7 +135,7 @@ export function defineSyncSystem<T extends Schema>(
   query: QueryFragment[],
   component: (entity: Entity) => Component<T>,
   value: (entity: Entity) => ComponentValue<T>,
-  options: { update?: boolean; runOnInit?: boolean } = { update: false, runOnInit: true }
+  options: { update?: boolean; runOnInit?: boolean } = { update: false, runOnInit: true },
 ) {
   defineSystem(
     world,
@@ -145,6 +145,6 @@ export function defineSyncSystem<T extends Schema>(
       if (type === UpdateType.Exit) removeComponent(component(entity), entity);
       if (options?.update && type === UpdateType.Update) setComponent(component(entity), entity, value(entity));
     },
-    options
+    options,
   );
 }

package/src/deprecated/createActionSystem.spec.ts

@@ -177,7 +177,7 @@ describe("ActionSystem", () => {
     expect(runQuery([HasValue(Action, { on: settlement1 })])).toEqual(new Set([entity1]));
     expect(runQuery([HasValue(Action, { on: settlement2 })])).toEqual(new Set([entity2]));
     expect(runQuery([HasValue(Action, { state: ActionState.Requested })])).toEqual(
-      new Set([entity1, entity2, entity3])
+      new Set([entity1, entity2, entity3]),
     );
   });
 

package/src/deprecated/createActionSystem.ts

@@ -15,7 +15,7 @@ export type ActionSystem = ReturnType<typeof createActionSystem>;
 export function createActionSystem<M = unknown>(
   world: World,
   txReduced$: Observable<string>,
-  waitForTransaction?: (tx: string) => Promise<void>
+  waitForTransaction?: (tx: string) => Promise<void>,
 ) {
   // Action component
   const Action = defineActionComponent<M>(world);
@@ -40,7 +40,7 @@ export function createActionSystem<M = unknown>(
    * @returns Components including pending updates
    */
   function withOptimisticUpdates<S extends Schema, M extends Metadata, T>(
-    component: Component<S, M, T>
+    component: Component<S, M, T>,
   ): OverridableComponent<S, M, T> {
     const optimisticComponent = componentsWithOptimisticUpdates[component.id] || overridableComponent(component);
 
@@ -99,7 +99,7 @@ export function createActionSystem<M = unknown>(
     // This subscriotion makes sure the action requirement is checked again every time
     // one of the referenced components changes or the pending updates map changes
     const subscription = merge(
-      ...Object.values(action.componentsWithOptimisticUpdates).map((c) => c.update$)
+      ...Object.values(action.componentsWithOptimisticUpdates).map((c) => c.update$),
     ).subscribe(() => checkRequirement(action));
     checkRequirement(action);
     disposer.set(action.id, { dispose: () => subscription?.unsubscribe() });