@codehz/ecs 0.7.2 → 0.7.4

package/src/archetype/archetype.ts

@@ -0,0 +1,472 @@
+import { normalizeComponentTypes } from "../component/type-utils";
+import type { EntityId, WildcardRelationId } from "../entity";
+import {
+  getComponentIdFromRelationId,
+  getDetailedIdType,
+  getIdType,
+  isDontFragmentComponent,
+  isWildcardRelationId,
+} from "../entity";
+import { isOptionalEntityId, type ComponentTuple, type ComponentType, type LifecycleHookEntry } from "../types";
+import { getOrCompute } from "../utils/utils";
+import {
+  buildCacheKey,
+  buildSingleComponent,
+  findMatchingDontFragmentRelations,
+  getWildcardRelationDataSource,
+  isRelationType,
+} from "./helpers";
+import type { DontFragmentStore } from "./store";
+
+/**
+ * Special value to represent missing component data
+ */
+export const MISSING_COMPONENT = Symbol("missing component");
+
+/**
+ * Archetype class for ECS architecture
+ * Represents a group of entities that share the same set of components
+ * Optimized for fast iteration and component access
+ */
+export class Archetype {
+  /**
+   * The component types that define this archetype
+   */
+  public readonly componentTypes: EntityId<any>[];
+
+  /**
+   * Set version of componentTypes for O(1) lookups in hot paths
+   */
+  public readonly componentTypeSet: ReadonlySet<EntityId<any>>;
+
+  /**
+   * List of entities in this archetype
+   */
+  private entities: EntityId[] = [];
+
+  /**
+   * Component data storage - maps component type to array of component data
+   * Each array index corresponds to the entity index in the entities array
+   */
+  private componentData: Map<EntityId<any>, any[]> = new Map();
+
+  /**
+   * Reverse mapping from entity to its index in this archetype
+   */
+  private entityToIndex: Map<EntityId, number> = new Map();
+
+  /**
+   * DontFragmentStore for relation data keyed by entity ID.
+   * This allows entities with different relation targets to share the same archetype
+   * without migration overhead when entities change archetypes.
+   */
+  private dontFragmentRelations: DontFragmentStore;
+
+  /**
+   * Multi-hooks that match this archetype
+   */
+  public readonly matchingMultiHooks: Set<LifecycleHookEntry> = new Set();
+
+  /**
+   * Cache for pre-computed component data sources to avoid repeated calculations
+   */
+  private componentDataSourcesCache: Map<string, (any[] | EntityId<any>[] | undefined)[]> = new Map();
+
+  constructor(componentTypes: EntityId<any>[], dontFragmentRelations: DontFragmentStore) {
+    this.componentTypes = normalizeComponentTypes(componentTypes);
+    this.componentTypeSet = new Set(this.componentTypes);
+    this.dontFragmentRelations = dontFragmentRelations;
+
+    for (const componentType of this.componentTypes) {
+      this.componentData.set(componentType, []);
+    }
+  }
+
+  get size(): number {
+    return this.entities.length;
+  }
+
+  /**
+   * Check if the given component types match this archetype
+   * @param componentTypes - Component types to check (can be in any order)
+   * @returns true if the types match this archetype's component set
+   * @note This method handles unsorted input by internally sorting for comparison
+   */
+  matches(componentTypes: EntityId<any>[]): boolean {
+    if (this.componentTypes.length !== componentTypes.length) return false;
+    const sortedTypes = normalizeComponentTypes(componentTypes);
+    return this.componentTypes.every((type, index) => type === sortedTypes[index]);
+  }
+
+  addEntity(entityId: EntityId, componentData: Map<EntityId<any>, any>): void {
+    if (this.entityToIndex.has(entityId)) {
+      throw new Error(`Entity ${entityId} is already in this archetype`);
+    }
+
+    const index = this.entities.length;
+    this.entities.push(entityId);
+    this.entityToIndex.set(entityId, index);
+
+    // Add component data for regular components
+    for (const componentType of this.componentTypes) {
+      const data = componentData.get(componentType);
+      this.getComponentData(componentType).push(!componentData.has(componentType) ? MISSING_COMPONENT : data);
+    }
+
+    // Add dontFragment relations separately
+    this.addDontFragmentRelations(entityId, componentData);
+  }
+
+  private addDontFragmentRelations(entityId: EntityId, componentData: Map<EntityId<any>, any>): void {
+    const dontFragmentData = new Map<EntityId<any>, any>();
+
+    for (const [componentType, data] of componentData) {
+      if (this.componentTypeSet.has(componentType)) continue;
+
+      const detailedType = getDetailedIdType(componentType);
+      if (isRelationType(detailedType) && isDontFragmentComponent(detailedType.componentId!)) {
+        dontFragmentData.set(componentType, data);
+      }
+    }
+
+    if (dontFragmentData.size > 0) {
+      this.dontFragmentRelations.set(entityId, dontFragmentData);
+    }
+  }
+
+  getEntity(entityId: EntityId): Map<EntityId<any>, any> | undefined {
+    const index = this.entityToIndex.get(entityId);
+    if (index === undefined) return undefined;
+
+    const entityData = new Map<EntityId<any>, any>();
+
+    // Add regular components
+    for (const componentType of this.componentTypes) {
+      const data = this.getComponentData(componentType)[index];
+      entityData.set(componentType, data === MISSING_COMPONENT ? undefined : data);
+    }
+
+    // Add dontFragment relations
+    const dontFragmentData = this.dontFragmentRelations.get(entityId);
+    if (dontFragmentData) {
+      for (const [componentType, data] of dontFragmentData) {
+        entityData.set(componentType, data);
+      }
+    }
+
+    return entityData;
+  }
+
+  getEntityDontFragmentRelations(entityId: EntityId): Map<EntityId<any>, any> | undefined {
+    return this.dontFragmentRelations.get(entityId);
+  }
+
+  dump(): Array<{ entity: EntityId; components: Map<EntityId<any>, any> }> {
+    return this.entities.map((entity, i) => {
+      const components = new Map<EntityId<any>, any>();
+
+      for (const componentType of this.componentTypes) {
+        const data = this.getComponentData(componentType)[i];
+        components.set(componentType, data === MISSING_COMPONENT ? undefined : data);
+      }
+
+      const dontFragmentData = this.dontFragmentRelations.get(entity);
+      if (dontFragmentData) {
+        for (const [componentType, data] of dontFragmentData) {
+          components.set(componentType, data);
+        }
+      }
+
+      return { entity, components };
+    });
+  }
+
+  removeEntity(entityId: EntityId): Map<EntityId<any>, any> | undefined {
+    const index = this.entityToIndex.get(entityId);
+    if (index === undefined) return undefined;
+
+    // Extract component data before removal
+    const removedData = new Map<EntityId<any>, any>();
+    for (const componentType of this.componentTypes) {
+      removedData.set(componentType, this.getComponentData(componentType)[index]);
+    }
+
+    // Include dontFragment relations
+    const dontFragmentData = this.dontFragmentRelations.get(entityId);
+    if (dontFragmentData) {
+      for (const [componentType, data] of dontFragmentData) {
+        removedData.set(componentType, data);
+      }
+      this.dontFragmentRelations.delete(entityId);
+    }
+
+    this.entityToIndex.delete(entityId);
+
+    // Swap-and-pop for O(1) removal
+    const lastIndex = this.entities.length - 1;
+    if (index !== lastIndex) {
+      const lastEntity = this.entities[lastIndex]!;
+      this.entities[index] = lastEntity;
+      this.entityToIndex.set(lastEntity, index);
+
+      for (const componentType of this.componentTypes) {
+        const dataArray = this.getComponentData(componentType);
+        dataArray[index] = dataArray[lastIndex];
+      }
+    }
+
+    this.entities.pop();
+    for (const componentType of this.componentTypes) {
+      this.getComponentData(componentType).pop();
+    }
+
+    return removedData;
+  }
+
+  exists(entityId: EntityId): boolean {
+    return this.entityToIndex.has(entityId);
+  }
+
+  get<T>(entityId: EntityId, componentType: WildcardRelationId<T>): [EntityId<unknown>, any][];
+  get<T>(entityId: EntityId, componentType: EntityId<T>): T;
+  get<T>(entityId: EntityId, componentType: EntityId<T> | WildcardRelationId<T>): T | [EntityId<unknown>, any][] {
+    const index = this.entityToIndex.get(entityId);
+    if (index === undefined) {
+      throw new Error(`Entity ${entityId} is not in this archetype`);
+    }
+
+    if (isWildcardRelationId(componentType)) {
+      return this.getWildcardRelations(entityId, index, componentType);
+    }
+
+    return this.getRegularComponent(entityId, index, componentType);
+  }
+
+  private getWildcardRelations<T>(
+    entityId: EntityId,
+    index: number,
+    componentType: WildcardRelationId<T>,
+  ): [EntityId<unknown>, any][] {
+    const componentId = getComponentIdFromRelationId(componentType);
+    const relations: [EntityId<unknown>, any][] = [];
+
+    // Check regular archetype components
+    for (const relType of this.componentTypes) {
+      const relDetailed = getDetailedIdType(relType);
+      if (isRelationType(relDetailed) && relDetailed.componentId === componentId) {
+        const dataArray = this.getComponentData(relType);
+        if (dataArray && dataArray[index] !== undefined) {
+          const data = dataArray[index];
+          relations.push([relDetailed.targetId, data === MISSING_COMPONENT ? undefined : data]);
+        }
+      }
+    }
+
+    // Check dontFragment relations
+    if (componentId !== undefined) {
+      findMatchingDontFragmentRelations(this.dontFragmentRelations.get(entityId), componentId, relations);
+    }
+
+    return relations;
+  }
+
+  private getRegularComponent<T>(entityId: EntityId, index: number, componentType: EntityId<T>): T {
+    if (this.componentTypeSet.has(componentType)) {
+      const data = this.getComponentData(componentType)[index]!;
+      if (data === MISSING_COMPONENT) {
+        throw new Error(`Component type ${componentType} not found for entity ${entityId}`);
+      }
+      return data as T;
+    }
+
+    const dontFragmentData = this.dontFragmentRelations.get(entityId);
+    if (dontFragmentData?.has(componentType)) {
+      return dontFragmentData.get(componentType);
+    }
+
+    throw new Error(`Component type ${componentType} not found for entity ${entityId}`);
+  }
+
+  getOptional<T>(entityId: EntityId, componentType: EntityId<T>): { value: T } | undefined {
+    const index = this.entityToIndex.get(entityId);
+    if (index === undefined) {
+      throw new Error(`Entity ${entityId} is not in this archetype`);
+    }
+
+    if (this.componentTypeSet.has(componentType)) {
+      const data = this.getComponentData(componentType)[index]!;
+      if (data === MISSING_COMPONENT) return undefined;
+      return { value: data as T };
+    }
+
+    const dontFragmentData = this.dontFragmentRelations.get(entityId);
+    if (dontFragmentData?.has(componentType)) {
+      return { value: dontFragmentData.get(componentType) };
+    }
+
+    return undefined;
+  }
+
+  set<T>(entityId: EntityId, componentType: EntityId<T>, data: T): void {
+    const index = this.entityToIndex.get(entityId);
+    if (index === undefined) {
+      throw new Error(`Entity ${entityId} is not in this archetype`);
+    }
+
+    if (this.componentData.has(componentType)) {
+      this.getComponentData(componentType)[index] = data;
+      return;
+    }
+
+    const detailedType = getDetailedIdType(componentType);
+    if (isRelationType(detailedType) && isDontFragmentComponent(detailedType.componentId!)) {
+      let dontFragmentData = this.dontFragmentRelations.get(entityId);
+      if (!dontFragmentData) {
+        dontFragmentData = new Map();
+        this.dontFragmentRelations.set(entityId, dontFragmentData);
+      }
+      dontFragmentData.set(componentType, data);
+      return;
+    }
+
+    throw new Error(`Component type ${componentType} is not in this archetype`);
+  }
+
+  getEntities(): EntityId[] {
+    return this.entities;
+  }
+
+  getEntityToIndexMap(): Map<EntityId, number> {
+    return this.entityToIndex;
+  }
+
+  getComponentData<T>(componentType: EntityId<T>): T[] {
+    const data = this.componentData.get(componentType);
+    if (!data) {
+      throw new Error(`Component type ${componentType} is not in this archetype`);
+    }
+    return data;
+  }
+
+  getOptionalComponentData<T>(componentType: EntityId<T>): T[] | undefined {
+    return this.componentData.get(componentType);
+  }
+
+  private getCachedComponentDataSources<const T extends readonly ComponentType<any>[]>(
+    componentTypes: T,
+  ): (any[] | EntityId<any>[] | undefined)[] {
+    const cacheKey = buildCacheKey(componentTypes);
+    return getOrCompute(this.componentDataSourcesCache, cacheKey, () =>
+      componentTypes.map((compType) => this.getComponentDataSource(compType)),
+    );
+  }
+
+  private getComponentDataSource(compType: ComponentType<any>): any[] | EntityId<any>[] | undefined {
+    const optional = isOptionalEntityId(compType);
+    const actualType = optional ? compType.optional : compType;
+    const idType = getIdType(actualType);
+
+    if (idType === "wildcard-relation") {
+      const componentId = getComponentIdFromRelationId(actualType)!;
+      return getWildcardRelationDataSource(this.componentTypes, componentId, optional);
+    }
+
+    return optional ? this.getOptionalComponentData(actualType) : this.getComponentData(actualType);
+  }
+
+  private buildComponentsForIndex<const T extends readonly ComponentType<any>[]>(
+    componentTypes: T,
+    componentDataSources: (any[] | EntityId<any>[] | undefined)[],
+    entityIndex: number,
+    entityId: EntityId,
+  ): ComponentTuple<T> {
+    return componentDataSources.map((dataSource, i) =>
+      buildSingleComponent(
+        componentTypes[i]!,
+        dataSource,
+        entityIndex,
+        entityId,
+        (type) => this.getComponentData(type),
+        this.dontFragmentRelations,
+      ),
+    ) as ComponentTuple<T>;
+  }
+
+  getEntitiesWithComponents<const T extends readonly ComponentType<any>[]>(
+    componentTypes: T,
+  ): Array<{ entity: EntityId; components: ComponentTuple<T> }> {
+    const result: Array<{ entity: EntityId; components: ComponentTuple<T> }> = [];
+    this.appendEntitiesWithComponents(componentTypes, result);
+    return result;
+  }
+
+  appendEntitiesWithComponents<const T extends readonly ComponentType<any>[]>(
+    componentTypes: T,
+    result: Array<{ entity: EntityId; components: ComponentTuple<T> }>,
+  ): void {
+    this.forEachWithComponents(componentTypes, (entity, ...components) => {
+      result.push({ entity, components });
+    });
+  }
+
+  *iterateWithComponents<const T extends readonly ComponentType<any>[]>(
+    componentTypes: T,
+  ): IterableIterator<[EntityId, ...ComponentTuple<T>]> {
+    const componentDataSources = this.getCachedComponentDataSources(componentTypes);
+
+    for (let entityIndex = 0; entityIndex < this.entities.length; entityIndex++) {
+      const entity = this.entities[entityIndex]!;
+      const components = this.buildComponentsForIndex(componentTypes, componentDataSources, entityIndex, entity);
+      yield [entity, ...components];
+    }
+  }
+
+  forEachWithComponents<const T extends readonly ComponentType<any>[]>(
+    componentTypes: T,
+    callback: (entity: EntityId, ...components: ComponentTuple<T>) => void,
+  ): void {
+    const componentDataSources = this.getCachedComponentDataSources(componentTypes);
+
+    for (let entityIndex = 0; entityIndex < this.entities.length; entityIndex++) {
+      const entity = this.entities[entityIndex]!;
+      const components = this.buildComponentsForIndex(componentTypes, componentDataSources, entityIndex, entity);
+      callback(entity, ...components);
+    }
+  }
+
+  forEach(callback: (entityId: EntityId, components: Map<EntityId<any>, any>) => void): void {
+    for (let i = 0; i < this.entities.length; i++) {
+      const components = new Map<EntityId<any>, any>();
+      for (const componentType of this.componentTypes) {
+        const data = this.getComponentData(componentType)[i];
+        components.set(componentType, data === MISSING_COMPONENT ? undefined : data);
+      }
+      callback(this.entities[i]!, components);
+    }
+  }
+
+  hasRelationWithComponentId(componentId: EntityId<any>): boolean {
+    // Check regular archetype components
+    for (const componentType of this.componentTypes) {
+      const detailedType = getDetailedIdType(componentType);
+      if (isRelationType(detailedType) && detailedType.componentId === componentId) {
+        return true;
+      }
+    }
+
+    // Check dontFragment relations
+    for (const entityId of this.entities) {
+      const entityDontFragmentRelations = this.dontFragmentRelations.get(entityId);
+      if (entityDontFragmentRelations) {
+        for (const relationType of entityDontFragmentRelations.keys()) {
+          const detailedType = getDetailedIdType(relationType);
+          if (isRelationType(detailedType) && detailedType.componentId === componentId) {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+}

package/src/archetype/helpers.ts

@@ -0,0 +1,186 @@
+import type { ComponentId, EntityId, WildcardRelationId } from "../entity";
+import {
+  getComponentIdFromRelationId,
+  getDetailedIdType,
+  getIdType,
+  getTargetIdFromRelationId,
+  isRelationId,
+} from "../entity";
+import { isOptionalEntityId, type ComponentType } from "../types";
+import { MISSING_COMPONENT } from "./archetype";
+import type { DontFragmentStore } from "./store";
+
+type DetailedIdType = ReturnType<typeof getDetailedIdType>;
+
+type RelationDetailedType =
+  | { type: "entity-relation"; componentId: ComponentId<any>; targetId: EntityId<any> }
+  | { type: "component-relation"; componentId: ComponentId<any>; targetId: ComponentId<any> };
+
+/**
+ * Find all wildcard relations matching a specific component ID from a components map
+ * @param components - Component entity's components map
+ * @param wildcardComponentId - The component ID to match (relation part)
+ * @returns Array of matching relation IDs
+ */
+export function findWildcardRelations(components: Map<EntityId, any>, wildcardComponentId: EntityId): EntityId<any>[] {
+  const result: EntityId<any>[] = [];
+  for (const [relId] of components) {
+    if (isRelationId(relId)) {
+      const decoded = getComponentIdFromRelationId(relId);
+      if (decoded === wildcardComponentId) {
+        result.push(relId);
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Check if a components map has any wildcard relations matching a component ID
+ * @param components - Component entity's components map
+ * @param wildcardComponentId - The component ID to match
+ * @returns True if at least one matching relation exists
+ */
+export function hasWildcardRelation(components: Map<EntityId, any>, wildcardComponentId: EntityId): boolean {
+  for (const relId of components.keys()) {
+    if (isRelationId(relId)) {
+      const decoded = getComponentIdFromRelationId(relId);
+      if (decoded === wildcardComponentId) return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a detailed type represents a relation (entity or component)
+ */
+export function isRelationType(detailedType: DetailedIdType): detailedType is RelationDetailedType {
+  return detailedType.type === "entity-relation" || detailedType.type === "component-relation";
+}
+
+/**
+ * Check if a component type matches a given component ID for relations
+ */
+export function matchesRelationComponentId(componentType: EntityId<any>, componentId: EntityId<any>): boolean {
+  const detailedType = getDetailedIdType(componentType);
+  return isRelationType(detailedType) && detailedType.componentId === componentId;
+}
+
+/**
+ * Find all relations in dontFragment data that match a component ID
+ */
+export function findMatchingDontFragmentRelations(
+  dontFragmentData: Map<EntityId<any>, any> | undefined,
+  componentId: EntityId<any>,
+  relations: [EntityId<unknown>, any][] = [],
+): [EntityId<unknown>, any][] {
+  if (!dontFragmentData) return relations;
+
+  for (const [relType, data] of dontFragmentData) {
+    const relDetailed = getDetailedIdType(relType);
+    if (isRelationType(relDetailed) && relDetailed.componentId === componentId) {
+      relations.push([relDetailed.targetId, data]);
+    }
+  }
+  return relations;
+}
+
+/**
+ * Build cache key for component types
+ */
+export function buildCacheKey(componentTypes: readonly ComponentType<any>[]): string {
+  return componentTypes.map((id) => (isOptionalEntityId(id) ? `opt(${id.optional})` : `${id}`)).join(",");
+}
+
+/**
+ * Get data source for wildcard relations from component types
+ */
+export function getWildcardRelationDataSource(
+  componentTypes: EntityId<any>[],
+  componentId: EntityId<any>,
+  optional: boolean,
+): EntityId<any>[] | undefined {
+  const matchingRelations = componentTypes.filter((ct) => matchesRelationComponentId(ct, componentId));
+  return optional ? (matchingRelations.length > 0 ? matchingRelations : undefined) : matchingRelations;
+}
+
+/**
+ * Build wildcard relation value from matching relations
+ */
+export function buildWildcardRelationValue(
+  wildcardRelationType: WildcardRelationId<any>,
+  matchingRelations: EntityId<any>[] | undefined,
+  getDataAtIndex: (relType: EntityId<any>) => any,
+  dontFragmentData: Map<EntityId<any>, any> | undefined,
+  entityId: EntityId,
+  optional: boolean,
+): any {
+  const relations: [EntityId<unknown>, any][] = [];
+  const targetComponentId = getComponentIdFromRelationId(wildcardRelationType);
+
+  // Add regular archetype relations
+  for (const relType of matchingRelations || []) {
+    const data = getDataAtIndex(relType);
+    const targetId = getTargetIdFromRelationId(relType)!;
+    relations.push([targetId, data === MISSING_COMPONENT ? undefined : data]);
+  }
+
+  // Add dontFragment relations
+  if (targetComponentId !== undefined) {
+    findMatchingDontFragmentRelations(dontFragmentData, targetComponentId, relations);
+  }
+
+  if (relations.length === 0) {
+    if (!optional) {
+      const componentId = getComponentIdFromRelationId(wildcardRelationType);
+      throw new Error(
+        `No matching relations found for mandatory wildcard relation component ${componentId} on entity ${entityId}`,
+      );
+    }
+    return undefined;
+  }
+
+  return optional ? { value: relations } : relations;
+}
+
+/**
+ * Build regular component value from data source
+ */
+export function buildRegularComponentValue(dataSource: any[] | undefined, entityIndex: number, optional: boolean): any {
+  if (dataSource === undefined) {
+    if (optional) return undefined;
+    throw new Error(`Component data not found for mandatory component type`);
+  }
+
+  const data = dataSource[entityIndex];
+  const result = data === MISSING_COMPONENT ? undefined : data;
+  return optional ? { value: result } : result;
+}
+
+/**
+ * Build a single component value based on its type
+ */
+export function buildSingleComponent(
+  compType: ComponentType<any>,
+  dataSource: any[] | EntityId<any>[] | undefined,
+  entityIndex: number,
+  entityId: EntityId,
+  getComponentData: (type: EntityId<any>) => any[],
+  dontFragmentRelations: DontFragmentStore,
+): any {
+  const optional = isOptionalEntityId(compType);
+  const actualType = optional ? compType.optional : compType;
+
+  if (getIdType(actualType) === "wildcard-relation") {
+    return buildWildcardRelationValue(
+      actualType as WildcardRelationId<any>,
+      dataSource as EntityId<any>[] | undefined,
+      (relType) => getComponentData(relType)[entityIndex],
+      dontFragmentRelations.get(entityId),
+      entityId,
+      optional,
+    );
+  } else {
+    return buildRegularComponentValue(dataSource as any[] | undefined, entityIndex, optional);
+  }
+}

package/src/archetype/store.ts

@@ -0,0 +1,33 @@
+import type { EntityId } from "../entity";
+
+/**
+ * Minimal interface for storing dontFragment relation data keyed by entity ID.
+ *
+ * Using an interface here decouples `Archetype` (and `world-commands.ts`) from
+ * the concrete `Map` used by `World`, making archetypes independently testable.
+ */
+export interface DontFragmentStore {
+  get(entityId: EntityId): Map<EntityId<any>, any> | undefined;
+  set(entityId: EntityId, data: Map<EntityId<any>, any>): void;
+  delete(entityId: EntityId): void;
+}
+
+/**
+ * Default implementation backed by a plain `Map`.
+ * Created once by `World` and shared with every `Archetype`.
+ */
+export class DontFragmentStoreImpl implements DontFragmentStore {
+  private readonly data: Map<EntityId, Map<EntityId<any>, any>> = new Map();
+
+  get(entityId: EntityId): Map<EntityId<any>, any> | undefined {
+    return this.data.get(entityId);
+  }
+
+  set(entityId: EntityId, data: Map<EntityId<any>, any>): void {
+    this.data.set(entityId, data);
+  }
+
+  delete(entityId: EntityId): void {
+    this.data.delete(entityId);
+  }
+}