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

package/src/deprecated/createActionSystem.ts

@@ -1,236 +0,0 @@
-import { merge, Observable } from "rxjs";
-import { mapObject, awaitStreamValue, uuid } from "@latticexyz/utils";
-import { ActionState } from "./constants";
-import { ActionData, ActionRequest } from "./types";
-import { defineActionComponent } from "./defineActionComponent";
-import { overridableComponent, setComponent, getComponentValue, updateComponent } from "../Component";
-import { createEntity } from "../Entity";
-import { World, OverridableComponent, Metadata, Component, Components, Entity, Schema } from "../types";
-
-export type ActionSystem = ReturnType<typeof createActionSystem>;
-
-/**
- * @deprecated For now, we suggest using `overridableComponent(Component)` and `addOverride`/`removeOverride` to manage overrides yourself.
- */
-export function createActionSystem<M = unknown>(
-  world: World,
-  txReduced$: Observable<string>,
-  waitForTransaction?: (tx: string) => Promise<void>,
-) {
-  // Action component
-  const Action = defineActionComponent<M>(world);
-
-  // Components that scheduled actions depend on including pending updates
-  const componentsWithOptimisticUpdates: { [id: string]: OverridableComponent<Schema> } = {};
-
-  // ActionData contains requirements and execute logic of scheduled actions.
-  // We also store the relevant subset of all componentsWithOptimisticUpdates in the action data,
-  // to recheck requirements only if relevant components updated.
-  const actionData = new Map<string, ActionData>();
-
-  // Disposers of requirement check autoruns for all pending actions
-  const disposer = new Map<string, { dispose: () => void }>();
-  world.registerDisposer(() => {
-    for (const { dispose } of disposer.values()) dispose();
-  });
-
-  /**
-   * Maps all components in a given components map to the respective components including pending updates
-   * @param component Component to be mapped to components including pending updates
-   * @returns Components including pending updates
-   */
-  function withOptimisticUpdates<S extends Schema, M extends Metadata, T>(
-    component: Component<S, M, T>,
-  ): OverridableComponent<S, M, T> {
-    const optimisticComponent = componentsWithOptimisticUpdates[component.id] || overridableComponent(component);
-
-    // If the component is not tracked yet, add it to the map of overridable components
-    if (!componentsWithOptimisticUpdates[component.id]) {
-      componentsWithOptimisticUpdates[component.id] = optimisticComponent;
-    }
-
-    // Typescript can't know that the optimistic component with this id has the same type as C
-    return optimisticComponent as OverridableComponent<S, M, T>;
-  }
-
-  /**
-   * Schedules an action. The action will be executed once its requirement is fulfilled.
-   * Note: the requirement will only be rechecked automatically if the requirement is based on components
-   * (or other mobx-observable values).
-   * @param actionRequest Action to be scheduled
-   * @returns index of the entity created for the action
-   */
-  function add<C extends Components, T>(actionRequest: ActionRequest<C, T, M>): Entity {
-    // Prevent the same actions from being scheduled multiple times
-    const existingAction = world.hasEntity(actionRequest.id as Entity);
-    if (existingAction) {
-      console.warn(`Action with id ${actionRequest.id} is already requested.`);
-      return actionRequest.id as Entity;
-    }
-
-    // Set the action component
-    const entity = createEntity(world, undefined, {
-      id: actionRequest.id,
-    });
-
-    setComponent(Action, entity, {
-      state: ActionState.Requested,
-      on: actionRequest.on,
-      metadata: actionRequest.metadata,
-      overrides: undefined,
-      txHash: undefined,
-    });
-
-    // Add components that are not tracked yet to internal overridable component map.
-    // Pending updates will be applied to internal overridable components.
-    for (const component of Object.values(actionRequest.components)) {
-      if (!componentsWithOptimisticUpdates[component.id])
-        componentsWithOptimisticUpdates[component.id] = overridableComponent(component);
-    }
-
-    // Store relevant components with pending updates along the action's requirement and execution logic
-    const action = {
-      ...actionRequest,
-      entity,
-      componentsWithOptimisticUpdates: mapObject(actionRequest.components, (c) => withOptimisticUpdates(c)),
-    } as unknown as ActionData;
-    actionData.set(action.id, action);
-
-    // 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$),
-    ).subscribe(() => checkRequirement(action));
-    checkRequirement(action);
-    disposer.set(action.id, { dispose: () => subscription?.unsubscribe() });
-
-    return entity;
-  }
-
-  /**
-   * Checks the requirement of a given action and executes the action if the requirement is fulfilled
-   * @param action Action to check the requirement of
-   * @returns void
-   */
-  function checkRequirement(action: ActionData) {
-    // Only check requirements of requested actions
-    if (getComponentValue(Action, action.entity)?.state !== ActionState.Requested) return;
-
-    // Check requirement on components including pending updates
-    const requirementResult = action.requirement(action.componentsWithOptimisticUpdates);
-
-    // Execute the action if the requirements are met
-    if (requirementResult) executeAction(action, requirementResult);
-  }
-
-  /**
-   * Executes the given action and sets the corresponding Action component
-   * @param action ActionData of the action to be executed
-   * @param requirementResult Result of the action's requirement function
-   * @returns void
-   */
-  async function executeAction<T>(action: ActionData, requirementResult: T) {
-    // Only execute actions that were requested before
-    if (getComponentValue(Action, action.entity)?.state !== ActionState.Requested) return;
-
-    // Update the action state
-    updateComponent(Action, action.entity, { state: ActionState.Executing });
-
-    // Compute overrides
-    const overrides = action
-      .updates(action.componentsWithOptimisticUpdates, requirementResult)
-      .map((o) => ({ ...o, id: uuid() }));
-
-    // Store overrides on Action component to be able to remove when action is done
-    updateComponent(Action, action.entity, { overrides: overrides.map((o) => `${o.id}/${o.component.id}`) });
-
-    // Set all pending updates of this action
-    for (const { component, value, entity, id } of overrides) {
-      componentsWithOptimisticUpdates[component.id].addOverride(id, { entity, value });
-    }
-
-    try {
-      // Execute the action
-      const tx = await action.execute(requirementResult);
-
-      // If the result includes a hash key (single tx) or hashes (multiple tx) key, wait for the transactions to complete before removing the pending actions
-      if (tx) {
-        // Wait for all tx events to be reduced
-        updateComponent(Action, action.entity, { state: ActionState.WaitingForTxEvents, txHash: tx });
-        await awaitStreamValue(txReduced$, (v) => v === tx);
-        updateComponent(Action, action.entity, { state: ActionState.TxReduced });
-        // TODO: extend ActionData type to be aware of whether waitForTransaction is set
-        if (action.awaitConfirmation) {
-          if (waitForTransaction) {
-            await waitForTransaction(tx);
-          } else {
-            throw new Error("action has awaitConfirmation but no waitForTransaction specified in createActionSystem");
-          }
-        }
-      }
-
-      updateComponent(Action, action.entity, { state: ActionState.Complete });
-    } catch (e) {
-      handleError(e, action);
-    }
-
-    // After the action is done executing (failed or completed), remove its actionData and remove the Action component
-    remove(action.id);
-  }
-
-  // Set the action's state to ActionState.Failed
-  function handleError(e: unknown, action: ActionData) {
-    console.error(e);
-    updateComponent(Action, action.entity, { state: ActionState.Failed });
-    remove(action.id);
-  }
-
-  /**
-   * Cancels the action with the given ID if it is in the "Requested" state.
-   * @param actionId ID of the action to be cancelled
-   * @returns void
-   */
-  function cancel(actionId: string): boolean {
-    const action = actionData.get(actionId);
-    if (!action || getComponentValue(Action, action.entity)?.state !== ActionState.Requested) {
-      console.warn(`Action ${actionId} was not found or is not in the "Requested" state.`);
-      return false;
-    }
-    updateComponent(Action, action.entity, { state: ActionState.Cancelled });
-    remove(actionId);
-    return true;
-  }
-
-  /**
-   * Removes actionData disposer of the action with the given ID and removes its pending updates.
-   * @param actionId ID of the action to be removed
-   */
-  function remove(actionId: string) {
-    const action = actionData.get(actionId);
-    if (!action) {
-      console.warn(`Trying to remove action ${actionId} that does not exist.`);
-      return;
-    }
-
-    // Remove this action's pending updates
-    const actionEntity = actionId as Entity;
-    const overrides = (actionEntity != null && getComponentValue(Action, actionEntity)?.overrides) || [];
-    for (const override of overrides) {
-      const [id, componentId] = override.split("/");
-      const component = componentsWithOptimisticUpdates[componentId];
-      component.removeOverride(id);
-    }
-
-    // Remove this action's autorun and corresponding disposer
-    disposer.get(actionId)?.dispose();
-    disposer.delete(actionId);
-
-    // Remove the action data
-    actionData.delete(actionId);
-
-    // Remove the action entity after some time
-    actionEntity != null && setTimeout(() => world.deleteEntity(actionEntity), 5000);
-  }
-
-  return { add, cancel, withOptimisticUpdates, Action };
-}

package/src/deprecated/defineActionComponent.ts

@@ -1,18 +0,0 @@
-import { defineComponent } from "../Component";
-import { Type } from "../constants";
-import { World, Component, SchemaOf, Metadata } from "../types";
-
-export function defineActionComponent<T = unknown>(world: World) {
-  const Action = defineComponent(
-    world,
-    {
-      state: Type.String,
-      on: Type.OptionalEntity,
-      metadata: Type.OptionalT,
-      overrides: Type.OptionalStringArray,
-      txHash: Type.OptionalString,
-    },
-    { id: "Action" },
-  );
-  return Action as Component<SchemaOf<typeof Action>, Metadata, T>;
-}

package/src/deprecated/index.ts

@@ -1,2 +0,0 @@
-export * from "./constants";
-export * from "./createActionSystem";

package/src/deprecated/types.ts

@@ -1,45 +0,0 @@
-import { ValueOf } from "@latticexyz/utils";
-import { Components, Entity, Override, SchemaOf } from "../types";
-
-export type ComponentUpdate<C extends Components> = ValueOf<{
-  [key in keyof C]: {
-    component: C[key];
-    entity: Entity;
-    value: Override<SchemaOf<C[key]>>["value"];
-  };
-}>;
-
-export type ActionRequest<C extends Components, T, M = unknown> = {
-  // Identifier of this action. Will be used as entity id of the Action component.
-  id: string;
-
-  // Specify which entity this action is related to.
-  on?: Entity;
-
-  // Components this action depends on in requirement and updates
-  components: C;
-
-  // Action will be executed once requirement function returns a truthy value.
-  // Requirement will be rechecked if any component value accessed in the requirement changes (including optimistic updates)
-  requirement: (componentsWithOptimisticUpdates: C) => T | null;
-
-  // Declare effects this action will have on components.
-  // Used to compute component values with optimistic updates for other requested actions.
-  updates: (componentsWithOptimisticUpdates: C, data: T) => ComponentUpdate<C>[];
-
-  // Logic to be executed when the action is executed.
-  // If txHashes are returned from the txQueue, the action will only be completed (and pending updates removed)
-  // once all events from the given txHashes have been received and reduced.
-  execute: (data: T) => Promise<string> | Promise<void> | void | undefined;
-
-  // Flag to set if the queue should wait for the underlying transaction to be confirmed (in addition to being reduced)
-  awaitConfirmation?: boolean;
-
-  // Metadata
-  metadata?: M;
-};
-
-export type ActionData<M = unknown> = ActionRequest<Components, unknown, M> & {
-  componentsWithOptimisticUpdates: Components;
-  entity: Entity;
-};

package/src/deprecated/waitForActionCompletion.ts

@@ -1,15 +0,0 @@
-import { Entity } from "../types";
-import { ActionState } from "./constants";
-import { defineActionComponent } from "./defineActionComponent";
-import { waitForComponentValueIn } from "./waitForComponentValueIn";
-
-export async function waitForActionCompletion(
-  Action: ReturnType<typeof defineActionComponent>,
-  entity: Entity,
-): Promise<void> {
-  return waitForComponentValueIn(Action, entity, [
-    { state: ActionState.Cancelled },
-    { state: ActionState.Failed },
-    { state: ActionState.Complete },
-  ]);
-}

package/src/deprecated/waitForComponentValueIn.ts

@@ -1,38 +0,0 @@
-import { deferred } from "@latticexyz/utils";
-import { filter, map, startWith } from "rxjs";
-import { componentValueEquals, getComponentValue } from "../Component";
-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>>[],
-): Promise<void> {
-  const [resolve, , promise] = deferred<void>();
-
-  const currentValue = getComponentValue(component, entity);
-  if (values.find((value) => componentValueEquals(value, currentValue))) {
-    resolve();
-  }
-
-  let dispose = resolve;
-
-  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
-  );
-
-  const subscription = value$
-    .pipe(
-      startWith(getComponentValue(component, entity)),
-      filter((currentValue) => Boolean(values.find((searchValue) => componentValueEquals(searchValue, currentValue)))),
-    )
-    .subscribe(() => {
-      resolve();
-      dispose();
-    });
-
-  dispose = () => subscription?.unsubscribe();
-
-  return promise;
-}

package/src/index.ts

@@ -1,9 +0,0 @@
-export * from "./Component";
-export * from "./Indexer";
-export * from "./Entity";
-export * from "./System";
-export * from "./World";
-export * from "./Query";
-export * from "./types";
-export * from "./constants";
-export * from "./utils";

package/src/types.ts

@@ -1,260 +0,0 @@
-import { Subject } from "rxjs";
-import { Type } from "./constants";
-import { Opaque } from "type-fest";
-
-/**
- * Entities are represented as symbols internally for memory efficiency.
- * To get the entity's string representation, use `getEntityString(entitySymbol)`
- */
-export type EntitySymbol = Opaque<symbol, "EntitySymbol">;
-
-export type Entity = Opaque<string, "Entity">;
-
-/**
- * Used to define the schema of a {@link Component}.
- * Uses {@link Type} enum to be able to access the component type in JavaScript as well as have TypeScript type checks.
- */
-export type Schema = {
-  [key: string]: Type;
-};
-
-/**
- * Used to add arbitrary metadata to components.
- */
-export type Metadata =
-  | {
-      [key: string]: unknown;
-    }
-  | undefined;
-
-/**
- * Mapping between JavaScript {@link Type} enum and corresponding TypeScript type.
- */
-export type ValueType<T = unknown> = {
-  [Type.Boolean]: boolean;
-  [Type.Number]: number;
-  [Type.BigInt]: bigint;
-  [Type.String]: string;
-  [Type.NumberArray]: number[];
-  [Type.BigIntArray]: bigint[];
-  [Type.StringArray]: string[];
-  [Type.Entity]: Entity;
-  [Type.EntityArray]: Entity[];
-  [Type.OptionalNumber]: number | undefined;
-  [Type.OptionalBigInt]: bigint | undefined;
-  [Type.OptionalBigIntArray]: bigint[] | undefined;
-  [Type.OptionalString]: string | undefined;
-  [Type.OptionalNumberArray]: number[] | undefined;
-  [Type.OptionalStringArray]: string[] | undefined;
-  [Type.OptionalEntity]: Entity | undefined;
-  [Type.OptionalEntityArray]: Entity[] | undefined;
-  [Type.T]: T;
-  [Type.OptionalT]: T | undefined;
-};
-
-/**
- * Used to infer the TypeScript type of a component value corresponding to a given {@link Schema}.
- */
-export type ComponentValue<S extends Schema = Schema, T = unknown> = {
-  [key in keyof S]: ValueType<T>[S[key]];
-};
-
-/**
- * Type of a component update corresponding to a given {@link Schema}.
- */
-export type ComponentUpdate<S extends Schema = Schema, T = unknown> = {
-  entity: Entity;
-  value: [ComponentValue<S, T> | undefined, ComponentValue<S, T> | undefined];
-  component: Component<S, Metadata, T>;
-};
-
-/**
- * Type of component returned by {@link defineComponent}.
- */
-export interface Component<S extends Schema = Schema, M extends Metadata = Metadata, T = unknown> {
-  id: string;
-  values: { [key in keyof S]: Map<EntitySymbol, ValueType<T>[S[key]]> };
-  schema: S;
-  metadata: M;
-  entities: () => IterableIterator<Entity>;
-  world: World;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  update$: Subject<ComponentUpdate<S, T>> & { observers: any };
-}
-
-/**
- * Type of indexer returned by {@link createIndexer}.
- */
-export type Indexer<S extends Schema, M extends Metadata = Metadata, T = unknown> = Component<S, M, T> & {
-  getEntitiesWithValue: (value: ComponentValue<S, T>) => Set<Entity>;
-};
-
-export type Components = {
-  [key: string]: Component;
-};
-
-export interface ComponentWithStream<S extends Schema, T = unknown> extends Component<S, Metadata, T> {
-  stream$: Subject<{ entity: Entity; value: ComponentValue<S, T> | undefined }>;
-}
-
-export type AnyComponentValue = ComponentValue<Schema>;
-
-export type AnyComponent = Component<Schema>;
-
-/**
- * Type of World returned by {@link createWorld}.
- */
-export type World = {
-  registerEntity: (options?: { id?: string; idSuffix?: string }) => Entity;
-  registerComponent: (component: Component) => void;
-  components: Component[];
-  getEntities: () => IterableIterator<Entity>;
-  dispose: () => void;
-  registerDisposer: (disposer: () => void) => void;
-  hasEntity: (entity: Entity) => boolean;
-  deleteEntity: (entity: Entity) => void;
-  entitySymbols: Set<EntitySymbol>;
-};
-
-export enum QueryFragmentType {
-  Has,
-  HasValue,
-  Not,
-  NotValue,
-  ProxyRead,
-  ProxyExpand,
-}
-
-export type HasQueryFragment<T extends Schema> = {
-  type: QueryFragmentType.Has;
-  component: Component<T>;
-};
-
-export type HasValueQueryFragment<T extends Schema> = {
-  type: QueryFragmentType.HasValue;
-  component: Component<T>;
-  value: Partial<ComponentValue<T>>;
-};
-
-export type NotQueryFragment<T extends Schema> = {
-  type: QueryFragmentType.Not;
-  component: Component<T>;
-};
-
-export type NotValueQueryFragment<T extends Schema> = {
-  type: QueryFragmentType.NotValue;
-  component: Component<T>;
-  value: Partial<ComponentValue<T>>;
-};
-
-export type ProxyReadQueryFragment = {
-  type: QueryFragmentType.ProxyRead;
-  component: Component<{ value: Type.Entity }>;
-  depth: number;
-};
-
-export type ProxyExpandQueryFragment = {
-  type: QueryFragmentType.ProxyExpand;
-  component: Component<{ value: Type.Entity }>;
-  depth: number;
-};
-
-export type QueryFragment<T extends Schema = Schema> =
-  | HasQueryFragment<T>
-  | HasValueQueryFragment<T>
-  | NotQueryFragment<T>
-  | NotValueQueryFragment<T>
-  | ProxyReadQueryFragment
-  | ProxyExpandQueryFragment;
-
-export type EntityQueryFragment<T extends Schema = Schema> =
-  | HasQueryFragment<T>
-  | HasValueQueryFragment<T>
-  | NotQueryFragment<T>
-  | NotValueQueryFragment<T>;
-
-export type SettingQueryFragment = ProxyReadQueryFragment | ProxyExpandQueryFragment;
-
-export type QueryFragments = QueryFragment<Schema>[];
-
-export type SchemaOf<C extends Component<Schema>> = C extends Component<infer S> ? S : never;
-
-export type Override<S extends Schema, T = unknown> = {
-  entity: Entity;
-  value: Partial<ComponentValue<S, T>> | null;
-};
-
-/**
- * Type of overridable component returned by {@link overridableComponent}.
- */
-export type OverridableComponent<S extends Schema = Schema, M extends Metadata = Metadata, T = unknown> = Component<
-  S,
-  M,
-  T
-> & {
-  addOverride: (overrideId: string, update: Override<S, T>) => void;
-  removeOverride: (overrideId: string) => void;
-};
-
-export type OptionalType =
-  | Type.OptionalNumber
-  | Type.OptionalBigInt
-  | Type.OptionalString
-  | Type.OptionalEntity
-  | Type.OptionalNumberArray
-  | Type.OptionalBigIntArray
-  | Type.OptionalStringArray
-  | Type.OptionalEntityArray;
-
-export function isOptionalType(t: Type): t is OptionalType {
-  return [
-    Type.OptionalNumber,
-    Type.OptionalBigInt,
-    Type.OptionalString,
-    Type.OptionalEntity,
-    Type.OptionalEntityArray,
-    Type.OptionalNumberArray,
-    Type.OptionalBigIntArray,
-    Type.OptionalStringArray,
-  ].includes(t);
-}
-
-export type ArrayType =
-  | Type.NumberArray
-  | Type.OptionalNumberArray
-  | Type.BigIntArray
-  | Type.OptionalBigIntArray
-  | Type.StringArray
-  | Type.OptionalStringArray
-  | Type.EntityArray
-  | Type.OptionalEntityArray;
-
-export function isArrayType(t: Type): t is ArrayType {
-  return [
-    Type.NumberArray,
-    Type.OptionalNumberArray,
-    Type.BigIntArray,
-    Type.OptionalBigIntArray,
-    Type.StringArray,
-    Type.OptionalStringArray,
-    Type.EntityArray,
-    Type.OptionalEntityArray,
-  ].includes(t);
-}
-
-export type NumberType = Type.Number | Type.OptionalNumber;
-export function isNumberType(t: Type): t is NumberType {
-  return [Type.Number, Type.OptionalNumber].includes(t);
-}
-
-export type EntityType = Type.Entity | Type.OptionalEntity;
-export function isEntityType(t: Type): t is EntityType {
-  return [Type.Entity, Type.OptionalEntity].includes(t);
-}
-
-export type Layer = {
-  world: World;
-  components: Record<string, Component<Schema>>;
-};
-
-export type Layers = Record<string, Layer>;