@awesome-ecs/abstract 0.13.0 → 0.13.2

package/dist/components/component.d.ts

@@ -1,36 +1,36 @@
-export type ComponentTypeUid = string | number;
-/**
- * The `IComponent` provides the main storage mechanism of `IEntity` state, and can be accessed and modified by Systems.
- *
- * The `IComponent` implementations should not contain any logic methods, apart from quick-access functionality.
- */
-export interface IComponent {
-    /**
-     * The `ComponentTypeUid` is an Unique Identifier for each Component type.
-     */
-    readonly componentType: ComponentTypeUid;
-    /**
-     * Specifies whether the Component state should be serialized as part of an `IEntitySnapshot`.
-     * Useful if the state needs to be replicated or updated through remote updates (e.g. coming from the server or peers).
-     */
-    readonly isSerializable: boolean;
-    /**
-     * @optional
-     * Specifies the current version of the component.
-     * Useful for keeping backwards-compatibility when the stored state might be of a different version.
-     */
-    readonly version?: number;
-    /**
-     * @optional
-     * The custom serialization function of this Component, used to transfer it into a Snapshot, or used for logging the Component stored state.
-     * If not provided, the standard `JSON.stringify()` functionality applies.
-     */
-    toJSON?(): string | object;
-    /**
-     * Allows for custom logic when loading the current from an `IEntitySnapshot`.
-     *
-     * The default behavior simply overwrites the fields with the target state.
-     * @param component The target component state to apply.
-     */
-    load?(targetState: this): void;
-}
+export type ComponentTypeUid = string | number;
+/**
+ * The `IComponent` provides the main storage mechanism of `IEntity` state, and can be accessed and modified by Systems.
+ *
+ * The `IComponent` implementations should not contain any logic methods, apart from quick-access functionality.
+ */
+export interface IComponent {
+    /**
+     * The `ComponentTypeUid` is an Unique Identifier for each Component type.
+     */
+    readonly componentType: ComponentTypeUid;
+    /**
+     * Specifies whether the Component state should be serialized as part of an `IEntitySnapshot`.
+     * Useful if the state needs to be replicated or updated through remote updates (e.g. coming from the server or peers).
+     */
+    readonly isSerializable: boolean;
+    /**
+     * @optional
+     * Specifies the current version of the component.
+     * Useful for keeping backwards-compatibility when the stored state might be of a different version.
+     */
+    readonly version?: number;
+    /**
+     * @optional
+     * The custom serialization function of this Component, used to transfer it into a Snapshot, or used for logging the Component stored state.
+     * If not provided, the standard `JSON.stringify()` functionality applies.
+     */
+    toJSON?(): string | object;
+    /**
+     * Allows for custom logic when loading the current from an `IEntitySnapshot`.
+     *
+     * The default behavior simply overwrites the fields with the target state.
+     * @param component The target component state to apply.
+     */
+    load?(targetState: this): void;
+}

package/dist/components/component.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=component.js.map

package/dist/components/identity-component.d.ts

@@ -1,24 +1,24 @@
-import { IComponent } from "./component";
-import { EntityTypeUid, IEntityModel } from "../entities/entity";
-import { Immutable } from "../utils/types";
-export declare enum BasicComponentType {
-    identity = "identity"
-}
-/**
- * The `IdentityComponent` contains basic information regarding what makes the current Entity unique.
- */
-export interface IdentityComponent<TModel extends IEntityModel> extends IComponent {
-    /**
-     * The Entity Type that defines what Category type the Entity is part of. There can be multiple Entities sharing the same EntityType.
-     */
-    readonly entityType: EntityTypeUid;
-    /**
-     * The Model is the basic information needed to create an `IEntity` when it's first initialized.
-     * It provides a first snapshot of information needed for the successful creation of an Entity instance.
-     */
-    readonly model: Immutable<TModel>;
-    /**
-     * Keeps track when the Entity's systems have ran last. Useful to calculate the `DeltaTime` between runs.
-     */
-    readonly lastUpdated: Date;
-}
+import { IComponent } from "./component";
+import { EntityTypeUid, IEntityModel } from "../entities/entity";
+import { Immutable } from "../utils/types";
+export declare enum BasicComponentType {
+    identity = "identity"
+}
+/**
+ * The `IdentityComponent` contains basic information regarding what makes the current Entity unique.
+ */
+export interface IdentityComponent<TModel extends IEntityModel> extends IComponent {
+    /**
+     * The Entity Type that defines what Category type the Entity is part of. There can be multiple Entities sharing the same EntityType.
+     */
+    readonly entityType: EntityTypeUid;
+    /**
+     * The Model is the basic information needed to create an `IEntity` when it's first initialized.
+     * It provides a first snapshot of information needed for the successful creation of an Entity instance.
+     */
+    readonly model: Immutable<TModel>;
+    /**
+     * Keeps track when the Entity's systems have ran last. Useful to calculate the `DeltaTime` between runs.
+     */
+    readonly lastUpdated: Date;
+}

package/dist/components/identity-component.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BasicComponentType = void 0;
-var BasicComponentType;
-(function (BasicComponentType) {
-    BasicComponentType["identity"] = "identity";
-})(BasicComponentType = exports.BasicComponentType || (exports.BasicComponentType = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicComponentType = void 0;
+var BasicComponentType;
+(function (BasicComponentType) {
+    BasicComponentType["identity"] = "identity";
+})(BasicComponentType = exports.BasicComponentType || (exports.BasicComponentType = {}));
 //# sourceMappingURL=identity-component.js.map

package/dist/entities/entity-events.d.ts

@@ -1,39 +1,52 @@
-import { IEntityProxy } from "./entity-proxies";
-export type EntityEventUid = string | number;
-export type EntityEventSubscriptionFilter = (event: IEntityEvent<IEventData>) => boolean;
-/**
- * The `IEventData` contains the event-specific state. At the very least, it contains the `Event Unique Identifier`.
- */
-export interface IEventData {
-    uid: EntityEventUid;
-}
-/**
- * The `IEntityEvent` represents the basic building block for a Pub/Sub pattern, to synchronize state between multiple Entities.
- *
- * The Events are scheduled as part of the `EntityUpdate` model. Systems subscribe and receive updates with the Events included in their `SystemContext`.
- */
-export interface IEntityEvent<TEventData extends IEventData> {
-    origin: IEntityProxy;
-    target?: IEntityProxy;
-    data: TEventData;
-}
-/**
- * The `IEntityEventsManager` represents the Pub/Sub broker for `IEntityEvent` instances.
- * It keeps track of Entity Subscriptions (as part of the Observer design-pattern).
- */
-export interface IEntityEventsManager {
-    subscribe(uid: EntityEventUid, entity: IEntityProxy, filter?: EntityEventSubscriptionFilter): void;
-    unsubscribe(uid: EntityEventUid, entity: IEntityProxy): void;
-    getSubscriptions(event: IEntityEvent<IEventData>): IEntityProxy[];
-    clearSubscriptions(uid?: EntityEventUid): void;
-}
-/**
- * The `IEntityEventsDispatcher` is the main access point for dispatching events to Entities.
- *
- * It can leverage the `IEntityEventsManager` to find Subscribers, and the `IEntityUpdateQueue` to register events
- * into each Observer Entity's next update.
- */
-export interface IEntityEventsDispatcher {
-    dispatchEvent(event: IEntityEvent<IEventData>, ...targets: IEntityProxy[]): void;
-    dispatchEvents(events: IEntityEvent<IEventData>[], ...targets: IEntityProxy[]): void;
-}
+import { IEntityProxy } from "./entity-proxies";
+export type EntityEventUid = string | number;
+export type EntityEventSubscriptionFilter = (event: IEntityEvent<IEventData>) => boolean;
+/**
+ * The `IEventData` contains the event-specific state. At the very least, it contains the `Event Unique Identifier`.
+ */
+export interface IEventData {
+    uid: EntityEventUid;
+}
+/**
+ * The `IEntityEvent` represents the basic building block for a Pub/Sub pattern, to synchronize state between multiple Entities.
+ *
+ * The Events are scheduled as part of the `EntityUpdate` model. Systems subscribe and receive updates with the Events included in their `SystemContext`.
+ */
+export interface IEntityEvent<TEventData extends IEventData> {
+    origin: IEntityProxy;
+    target?: IEntityProxy;
+    data: TEventData;
+}
+/**
+ * The `IEntityEventsManager` represents the Pub/Sub broker for `IEntityEvent` instances.
+ * It keeps track of Entity Subscriptions (as part of the Observer design-pattern).
+ */
+export interface IEntityEventsManager {
+    subscribe(uid: EntityEventUid, entity: IEntityProxy, filter?: EntityEventSubscriptionFilter): void;
+    unsubscribe(uid: EntityEventUid, entity: IEntityProxy): void;
+    getSubscriptions(event: IEntityEvent<IEventData>): IEntityProxy[];
+    /**
+     * Removes all Subscriptions for all Entities.
+     */
+    clearSubscriptions(): void;
+    /**
+     * Removes all Subscriptions for the given Event.
+     * @param uid The Event UID to remove all Subscribers from.
+     */
+    clearSubscriptionsForEvent(uid: EntityEventUid): void;
+    /**
+     * Removes all Event Subscriptions for the given Entity.
+     * @param entity The Entity to remove all of it's Event Subscriptions.
+     */
+    clearSubscriptionsForEntity(entity: IEntityProxy): void;
+}
+/**
+ * The `IEntityEventsDispatcher` is the main access point for dispatching events to Entities.
+ *
+ * It can leverage the `IEntityEventsManager` to find Subscribers, and the `IEntityUpdateQueue` to register events
+ * into each Observer Entity's next update.
+ */
+export interface IEntityEventsDispatcher {
+    dispatchEvent(event: IEntityEvent<IEventData>, ...targets: IEntityProxy[]): void;
+    dispatchEvents(events: IEntityEvent<IEventData>[], ...targets: IEntityProxy[]): void;
+}

package/dist/entities/entity-events.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=entity-events.js.map

package/dist/entities/entity-proxies.d.ts

@@ -1,25 +1,25 @@
-import { EntityTypeUid, EntityUid, IEntity } from "./entity";
-/**
- * The `IEntityProxy` represents a pointer to another `Entity`.
- */
-export interface IEntityProxy {
-    readonly entityType: EntityTypeUid;
-    readonly entityUid: EntityUid;
-}
-/**
- * A utility extension of `IEntityProxy`.
- * Useful for providing strong `Type` information when using the IEntityProxy.
- */
-export interface EntityProxy<TEntity extends IEntity> extends IEntityProxy {
-}
-/**
- * The `IEntityProxiesManager` is a helper to encapsulate logic for registering & removing Entity proxies.
- *
- * It handles the complexities of bi-directional registrations and offers an abstraction for the Proxy handling.
- */
-export interface IEntityProxiesManager {
-    registerProxy(entity: IEntity, proxy: IEntityProxy, cleanup?: boolean): void;
-    registerProxies(entity: IEntity, proxies: IEntityProxy[], cleanup?: boolean): void;
-    removeProxy(entity: IEntity, proxy: IEntityProxy): void;
-    removeProxies(entity: IEntity, proxyEntityType?: EntityTypeUid): void;
-}
+import { EntityTypeUid, EntityUid, IEntity } from "./entity";
+/**
+ * The `IEntityProxy` represents a pointer to another `Entity`.
+ */
+export interface IEntityProxy {
+    readonly entityType: EntityTypeUid;
+    readonly entityUid: EntityUid;
+}
+/**
+ * A utility extension of `IEntityProxy`.
+ * Useful for providing strong `Type` information when using the IEntityProxy.
+ */
+export interface EntityProxy<TEntity extends IEntity> extends IEntityProxy {
+}
+/**
+ * The `IEntityProxiesManager` is a helper to encapsulate logic for registering & removing Entity proxies.
+ *
+ * It handles the complexities of bi-directional registrations and offers an abstraction for the Proxy handling.
+ */
+export interface IEntityProxiesManager {
+    registerProxy(entity: IEntity, proxy: IEntityProxy, cleanup?: boolean): void;
+    registerProxies(entity: IEntity, proxies: IEntityProxy[], cleanup?: boolean): void;
+    removeProxy(entity: IEntity, proxy: IEntityProxy): void;
+    removeProxies(entity: IEntity, proxyEntityType?: EntityTypeUid): void;
+}

package/dist/entities/entity-proxies.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=entity-proxies.js.map

package/dist/entities/entity-queue.d.ts

@@ -1,31 +1,31 @@
-import { IEntityModel } from "./entity";
-import { IEntityProxy } from "./entity-proxies";
-import { IEntitySnapshot } from "./entity-snapshot";
-/**
- * The `EntityUpdateType` specifies whether the current should `update` or `remove` the Entity.
- */
-export declare enum EntityUpdateType {
-    update = "update",
-    remove = "remove"
-}
-/**
- * The `IEntityUpdate` represents an Entity update that should be applied over an (existing) Entity.
- */
-export interface IEntityUpdate {
-    type: EntityUpdateType;
-    entity: IEntityProxy;
-    model?: IEntityModel;
-    snapshot?: IEntitySnapshot;
-}
-/**
- * The `IEntityUpdateQueue` is the main mechanism to queue and retrieve `EntityUpdate` instances.
- *
- * The interface can be implemented using a simple queue mechanism, or perhaps, a Priority Queue.
- */
-export interface IEntityUpdateQueue {
-    readonly size: number;
-    enqueue(change: IEntityUpdate): void;
-    dequeue(): IEntityUpdate;
-    peek(): IEntityUpdate;
-    clear(): void;
-}
+import { IEntityModel } from "./entity";
+import { IEntityProxy } from "./entity-proxies";
+import { IEntitySnapshot } from "./entity-snapshot";
+/**
+ * The `EntityUpdateType` specifies whether the current should `update` or `remove` the Entity.
+ */
+export declare enum EntityUpdateType {
+    update = "update",
+    remove = "remove"
+}
+/**
+ * The `IEntityUpdate` represents an Entity update that should be applied over an (existing) Entity.
+ */
+export interface IEntityUpdate {
+    type: EntityUpdateType;
+    entity: IEntityProxy;
+    model?: IEntityModel;
+    snapshot?: IEntitySnapshot;
+}
+/**
+ * The `IEntityUpdateQueue` is the main mechanism to queue and retrieve `EntityUpdate` instances.
+ *
+ * The interface can be implemented using a simple queue mechanism, or perhaps, a Priority Queue.
+ */
+export interface IEntityUpdateQueue {
+    readonly size: number;
+    enqueue(change: IEntityUpdate): void;
+    dequeue(): IEntityUpdate;
+    peek(): IEntityUpdate;
+    clear(): void;
+}

package/dist/entities/entity-queue.js

@@ -1,12 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityUpdateType = void 0;
-/**
- * The `EntityUpdateType` specifies whether the current should `update` or `remove` the Entity.
- */
-var EntityUpdateType;
-(function (EntityUpdateType) {
-    EntityUpdateType["update"] = "update";
-    EntityUpdateType["remove"] = "remove";
-})(EntityUpdateType = exports.EntityUpdateType || (exports.EntityUpdateType = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityUpdateType = void 0;
+/**
+ * The `EntityUpdateType` specifies whether the current should `update` or `remove` the Entity.
+ */
+var EntityUpdateType;
+(function (EntityUpdateType) {
+    EntityUpdateType["update"] = "update";
+    EntityUpdateType["remove"] = "remove";
+})(EntityUpdateType = exports.EntityUpdateType || (exports.EntityUpdateType = {}));
 //# sourceMappingURL=entity-queue.js.map

package/dist/entities/entity-repository.d.ts

@@ -1,16 +1,16 @@
-import { EntityTypeUid, IEntity } from "./entity";
-import { IEntityProxy } from "./entity-proxies";
-/**
- * The `IEntityRepository` is the central storage for keeping track of existing Entities.
- * It provides basic CRUD functionality.
- */
-export interface IEntityRepository {
-    readonly size: number;
-    has(proxy: IEntityProxy): boolean;
-    get<TEntity extends IEntity>(proxy: IEntityProxy): TEntity;
-    getAll<TEntity extends IEntity>(entityType: EntityTypeUid): TEntity[];
-    listAll(): IEntity[];
-    set(entity: IEntity): void;
-    delete(proxy: IEntityProxy): void;
-    clear(entityType: EntityTypeUid): void;
-}
+import { EntityTypeUid, IEntity } from "./entity";
+import { IEntityProxy } from "./entity-proxies";
+/**
+ * The `IEntityRepository` is the central storage for keeping track of existing Entities.
+ * It provides basic CRUD functionality.
+ */
+export interface IEntityRepository {
+    readonly size: number;
+    has(proxy: IEntityProxy): boolean;
+    get<TEntity extends IEntity>(proxy: IEntityProxy): TEntity;
+    getAll<TEntity extends IEntity>(entityType: EntityTypeUid): TEntity[];
+    listAll(): IEntity[];
+    set(entity: IEntity): void;
+    delete(proxy: IEntityProxy): void;
+    clear(entityType: EntityTypeUid): void;
+}

package/dist/entities/entity-repository.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=entity-repository.js.map

package/dist/entities/entity-scheduler.d.ts

@@ -1,11 +1,11 @@
-import { IEntityProxy } from "./entity-proxies";
-/**
- * The `IEntityScheduler` is the main way of queuing `IEntityUpdate` instances on an Interval (based on time or a custom implementation).
- *
- * It usually reads the Entities from the `IEntityRepository`, and uses the `IEntityUpdateQueue` to enqueue Entity updates.
- */
-export interface IEntityScheduler {
-    schedule(entityProxy: IEntityProxy, intervalMs?: number): void;
-    remove(entityProxy: IEntityProxy): void;
-    has(entityProxy: IEntityProxy): boolean;
-}
+import { IEntityProxy } from "./entity-proxies";
+/**
+ * The `IEntityScheduler` is the main way of queuing `IEntityUpdate` instances on an Interval (based on time or a custom implementation).
+ *
+ * It usually reads the Entities from the `IEntityRepository`, and uses the `IEntityUpdateQueue` to enqueue Entity updates.
+ */
+export interface IEntityScheduler {
+    schedule(entityProxy: IEntityProxy, intervalMs?: number): void;
+    remove(entityProxy: IEntityProxy): void;
+    has(entityProxy: IEntityProxy): boolean;
+}

package/dist/entities/entity-scheduler.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=entity-scheduler.js.map

package/dist/entities/entity-snapshot.d.ts

@@ -1,24 +1,24 @@
-import { IdentityComponent } from "../components/identity-component";
-import { IComponent } from "../components/component";
-import { IEntityProxy } from "./entity-proxies";
-import { IEntity, IEntityModel } from "./entity";
-import { IEntityEvent, IEventData } from "./entity-events";
-/**
- * The `IEntitySnapshot` contains the full or partial serializable state of an Entity.
- *
- * It can be used to capture Entity state changes (deltas) or update existing Entity with changes coming from a remote source (e.g. server or other peers).
- */
-export interface IEntitySnapshot {
-    readonly identity?: Readonly<IdentityComponent<IEntityModel>>;
-    readonly components?: IComponent[];
-    readonly proxies?: IEntityProxy[];
-    readonly events?: IEntityEvent<IEventData>[];
-}
-/**
- * The `IEntitySnapshotProvider` is the main provider for both creating snapshots for an Entity,
- * as well as updating Entity state based off an `IEntitySnapshot`.
- */
-export interface IEntitySnapshotProvider {
-    applySnapshot(entity: IEntity, snapshot: IEntitySnapshot): void;
-    createSnapshot(entity: IEntity): IEntitySnapshot;
-}
+import { IdentityComponent } from "../components/identity-component";
+import { IComponent } from "../components/component";
+import { IEntityProxy } from "./entity-proxies";
+import { IEntity, IEntityModel } from "./entity";
+import { IEntityEvent, IEventData } from "./entity-events";
+/**
+ * The `IEntitySnapshot` contains the full or partial serializable state of an Entity.
+ *
+ * It can be used to capture Entity state changes (deltas) or update existing Entity with changes coming from a remote source (e.g. server or other peers).
+ */
+export interface IEntitySnapshot {
+    readonly identity?: Readonly<IdentityComponent<IEntityModel>>;
+    readonly components?: IComponent[];
+    readonly proxies?: IEntityProxy[];
+    readonly events?: IEntityEvent<IEventData>[];
+}
+/**
+ * The `IEntitySnapshotProvider` is the main provider for both creating snapshots for an Entity,
+ * as well as updating Entity state based off an `IEntitySnapshot`.
+ */
+export interface IEntitySnapshotProvider {
+    applySnapshot(entity: IEntity, snapshot: IEntitySnapshot): void;
+    createSnapshot(entity: IEntity): IEntitySnapshot;
+}

package/dist/entities/entity-snapshot.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=entity-snapshot.js.map

package/dist/entities/entity.d.ts

@@ -1,31 +1,33 @@
-import { IdentityComponent } from "../components/identity-component";
-import { ComponentTypeUid, IComponent } from "../components/component";
-import { IEntityProxy } from "./entity-proxies";
-export type EntityTypeUid = string | number;
-export type EntityUid = string | number;
-/**
- * The `IEntityModel` represents the basic identity information about the current `IEntity`.
- * It's mandatory for each Entity, and it contains the minimal-required information needed for instantiating the Entity.
- */
-export interface IEntityModel {
-    readonly uid: EntityUid;
-}
-/**
- * The `IEntity` is basically a container of Components and Entity Proxies.
- * Only Systems can manipulate the internal state of the Entity, by altering its Components' data.
- *
- * The implementations of `IEntity` can contain quick-access methods for `Components` or `Proxies` but should not contain any logic
- * apart from quick-access functionality.
- */
-export interface IEntity {
-    readonly components: ReadonlyMap<ComponentTypeUid, IComponent>;
-    readonly proxies: Map<EntityTypeUid, Map<EntityUid, IEntityProxy>>;
-    /**
-     * The IdentityComponent represents mandatory state any Entity needs to have.
-     */
-    readonly identity: Readonly<IdentityComponent<IEntityModel>>;
-    /**
-     * Own Proxy reference, points to this Entity. Useful for quick access of Proxy data.
-     */
-    readonly myProxy: Readonly<IEntityProxy>;
-}
+import { IdentityComponent } from "../components/identity-component";
+import { ComponentTypeUid, IComponent } from "../components/component";
+import { IEntityProxy } from "./entity-proxies";
+import { BooleanProps } from "../utils/types";
+export type EntityTypeUid = string | number;
+export type EntityUid = string | number;
+/**
+ * The `IEntityModel` represents the basic identity information about the current `IEntity`.
+ * It's mandatory for each Entity, and it contains the minimal-required information needed for instantiating the Entity.
+ */
+export interface IEntityModel<TFeatures extends BooleanProps<TFeatures> = unknown> {
+    readonly uid: EntityUid;
+    readonly features?: TFeatures;
+}
+/**
+ * The `IEntity` is basically a container of Components and Entity Proxies.
+ * Only Systems can manipulate the internal state of the Entity, by altering its Components' data.
+ *
+ * The implementations of `IEntity` can contain quick-access methods for `Components` or `Proxies` but should not contain any logic
+ * apart from quick-access functionality.
+ */
+export interface IEntity {
+    readonly components: ReadonlyMap<ComponentTypeUid, IComponent>;
+    readonly proxies: Map<EntityTypeUid, Map<EntityUid, IEntityProxy>>;
+    /**
+     * The IdentityComponent represents mandatory state any Entity needs to have.
+     */
+    readonly identity: Readonly<IdentityComponent<IEntityModel>>;
+    /**
+     * Own Proxy reference, points to this Entity. Useful for quick access of Proxy data.
+     */
+    readonly myProxy: Readonly<IEntityProxy>;
+}

package/dist/entities/entity.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=entity.js.map

package/dist/factories/context-factory.d.ts

@@ -1,9 +1,9 @@
-import { IEntity } from "../entities/entity";
-import { ISystemPipelineContext } from "../systems/system-pipeline-context";
-/**
- * The IContextFactory can be used as an abstraction layer to quickly create SystemPipelineContext objects,
- * without having to manually resolve all of their dependencies.
- */
-export interface IContextFactory {
-    createPipelineContext<TEntity extends IEntity>(entity: TEntity): ISystemPipelineContext<TEntity>;
-}
+import { IEntity } from "../entities/entity";
+import { ISystemPipelineContext } from "../systems/system-pipeline-context";
+/**
+ * The IContextFactory can be used as an abstraction layer to quickly create SystemPipelineContext objects,
+ * without having to manually resolve all of their dependencies.
+ */
+export interface IContextFactory {
+    createPipelineContext<TEntity extends IEntity>(entity: TEntity): ISystemPipelineContext<TEntity>;
+}

package/dist/factories/context-factory.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=context-factory.js.map