@latticexyz/recs 2.0.0-next.17 → 2.0.0-next.18

package/src/Component.ts

@@ -23,6 +23,7 @@ export type ComponentMutationOptions = {
   skipUpdateStream?: boolean;
 };
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function getComponentName(component: Component<any, any, any>) {
   return (
     component.metadata?.componentName ??
@@ -55,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();
@@ -86,7 +87,7 @@ export function setComponent<S extends Schema, T = unknown>(
   component: Component<S, Metadata, T>,
   entity: Entity,
   value: ComponentValue<S, T>,
-  options: ComponentMutationOptions = {}
+  options: ComponentMutationOptions = {},
 ) {
   const entitySymbol = getEntitySymbol(entity);
   const prevValue = getComponentValue(component, entity);
@@ -110,7 +111,7 @@ export function setComponent<S extends Schema, T = unknown>(
           "for entity",
           entity,
           ". Existing keys: ",
-          Object.keys(component.values)
+          Object.keys(component.values),
         );
       }
     }
@@ -141,7 +142,7 @@ export function updateComponent<S extends Schema, T = unknown>(
   entity: Entity,
   value: Partial<ComponentValue<S, T>>,
   initialValue?: ComponentValue<S, T>,
-  options: ComponentMutationOptions = {}
+  options: ComponentMutationOptions = {},
 ) {
   const currentValue = getComponentValue(component, entity);
   if (currentValue === undefined) {
@@ -163,7 +164,7 @@ 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,
-  options: ComponentMutationOptions = {}
+  options: ComponentMutationOptions = {},
 ) {
   const entitySymbol = getEntitySymbol(entity);
   const prevValue = getComponentValue(component, entity);
@@ -184,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];
@@ -201,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);
@@ -230,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}`);
@@ -253,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;
@@ -276,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];
 }
@@ -290,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)) {
@@ -315,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();
 }
@@ -335,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;
 
@@ -457,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$);
 
@@ -475,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);
@@ -509,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) {
@@ -520,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

@@ -18,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() });

package/src/deprecated/defineActionComponent.ts

@@ -12,7 +12,7 @@ export function defineActionComponent<T = unknown>(world: World) {
       overrides: Type.OptionalStringArray,
       txHash: Type.OptionalString,
     },
-    { id: "Action" }
+    { id: "Action" },
   );
   return Action as Component<SchemaOf<typeof Action>, Metadata, T>;
 }

package/src/deprecated/waitForActionCompletion.ts

@@ -5,7 +5,7 @@ import { waitForComponentValueIn } from "./waitForComponentValueIn";
 
 export async function waitForActionCompletion(
   Action: ReturnType<typeof defineActionComponent>,
-  entity: Entity
+  entity: Entity,
 ): Promise<void> {
   return waitForComponentValueIn(Action, entity, [
     { state: ActionState.Cancelled },

package/src/deprecated/waitForComponentValueIn.ts

@@ -6,7 +6,7 @@ import { Component, Metadata, Entity, ComponentValue, Schema } from "../types";
 export function waitForComponentValueIn<S extends Schema, T>(
   component: Component<S, Metadata, T>,
   entity: Entity,
-  values: Partial<ComponentValue<S>>[]
+  values: Partial<ComponentValue<S>>[],
 ): Promise<void> {
   const [resolve, , promise] = deferred<void>();
 
@@ -19,13 +19,13 @@ export function waitForComponentValueIn<S extends Schema, T>(
 
   const value$ = component.update$.pipe(
     filter((update) => update.entity === entity), // Ignore updates of other entities
-    map((update) => update.value[0]) // Map the update to the current value
+    map((update) => update.value[0]), // Map the update to the current value
   );
 
   const subscription = value$
     .pipe(
       startWith(getComponentValue(component, entity)),
-      filter((currentValue) => Boolean(values.find((searchValue) => componentValueEquals(searchValue, currentValue))))
+      filter((currentValue) => Boolean(values.find((searchValue) => componentValueEquals(searchValue, currentValue)))),
     )
     .subscribe(() => {
       resolve();