@awesome-ecs/abstract 0.8.0 → 0.9.0

package/dist/components/component.d.ts

@@ -1,17 +1,36 @@
 export declare type ComponentTypeUid = string | number;
 /**
- * The Component provides the main storage mechanism of Entity state, and can be accessed and modified by Systems.
+ * 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 ComponentType is an Unique identifier for each Component type.
-     *
-     * It's possible to have multiple instances of the same Component type across different Entities,
-     * but only one Component type can exist on one Entity.
+     * The `ComponentTypeUid` is an Unique Identifier for each Component type.
      */
     readonly componentType: ComponentTypeUid;
     /**
-     * The serialization mechanism of this Component, when used to transfer it into a Snapshot, or used for logging the Component stored state.
+     * 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/identity-component.d.ts

@@ -4,7 +4,7 @@ export declare enum BasicComponentType {
     identity = "identity"
 }
 /**
- * Each Entity will have an Identity, containing basic information regarding what makes the current Entity unique.
+ * The `IdentityComponent` contains basic information regarding what makes the current Entity unique.
  */
 export interface IdentityComponent<TModel extends IEntityModel> extends IComponent {
     /**
@@ -12,8 +12,12 @@ export interface IdentityComponent<TModel extends IEntityModel> extends ICompone
      */
     readonly entityType: EntityTypeUid;
     /**
-     * The Model is the basic information needed to create an Entity when it's first initialized.
+     * 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: TModel;
+    /**
+     * Keeps track when the Entity's systems have ran last. Useful to calculate the `DeltaTime` between runs.
+     */
+    readonly lastUpdated: Date;
 }

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

@@ -1,15 +1,16 @@
-import { IEntityProxy } from "./entity-proxy";
+import { IEntityProxy } from "./entity-proxies";
 export declare type EntityEventUid = string | number;
 export declare 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;
 }
 /**
- * Entity Events represent the basic building blocks for a Pub/Sub pattern, to synchronize
- * state between multiple Entities.
+ * The `IEntityEvent` represents the basic building block for a Pub/Sub pattern, to synchronize state between multiple Entities.
  *
- * The Events are past actions that already happened within a state. They are scheduled as part of the EntityUpdate model.
- * Other Systems subscribe and receive updates with the Events included in their SystemContext model.
+ * 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;
@@ -17,7 +18,8 @@ export interface IEntityEvent<TEventData extends IEventData> {
     data: TEventData;
 }
 /**
- * The EntityEventsManager represents the Pub/Sub broker for EntityEvents.
+ * 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;
@@ -26,10 +28,10 @@ export interface IEntityEventsManager {
     clearSubscriptions(uid?: EntityEventUid): void;
 }
 /**
- * The EntityEventsDispatcher is the main access point for dispatching events to Entities.
+ * The `IEntityEventsDispatcher` is the main access point for dispatching events to Entities.
  *
- * It can leverage the IEntityEvents manager to find Subscribers, and the IEntityUpdateQueue to register events
- * into the Entity's next update.
+ * 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;

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

@@ -0,0 +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;
+}

package/dist/entities/{entity-proxy.js → entity-proxies.js}

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

package/dist/entities/entity-proxies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-proxies.js","sourceRoot":"","sources":["../../src/entities/entity-proxies.ts"],"names":[],"mappings":""}

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

@@ -1,24 +1,25 @@
 import { IEntityModel } from "./entity";
-import { IEntityEvent, IEventData } from "./entity-events";
-import { IEntityProxy } from "./entity-proxy";
+import { IEntityProxy } from "./entity-proxies";
+import { IEntitySnapshot } from "./entity-snapshot";
 /**
- * The Entity update state for this change.
+ * The `EntityUpdateType` specifies whether the current should `update` or `remove` the Entity.
  */
 export declare enum EntityUpdateType {
     update = "update",
     remove = "remove"
 }
 /**
- * Represents an Entity update that should be applied over an (existing) Entity.
+ * The `IEntityUpdate` represents an Entity update that should be applied over an (existing) Entity.
  */
 export interface IEntityUpdate {
     type: EntityUpdateType;
     entity: IEntityProxy;
     model?: IEntityModel;
-    events?: IEntityEvent<IEventData>[];
+    snapshot?: IEntitySnapshot;
 }
 /**
- * The Entity Updates will be queued up, and can be picked up in order.
+ * 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 {

package/dist/entities/entity-queue.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityUpdateType = void 0;
 /**
- * The Entity update state for this change.
+ * The `EntityUpdateType` specifies whether the current should `update` or `remove` the Entity.
  */
 var EntityUpdateType;
 (function (EntityUpdateType) {

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

@@ -1,24 +1,15 @@
-import { EntityUid, EntityTypeUid, IEntity } from "./entity";
+import { EntityTypeUid, IEntity } from "./entity";
+import { IEntityProxy } from "./entity-proxies";
 /**
- * The Entity Repository internal structure. Holds the Entity as well as LastUpdate time.
- */
-export interface StoredEntity<TEntity extends IEntity> {
-    entity: TEntity;
-    lastUpdate: Date;
-}
-/**
- * The Entity Repository is the main storage for keeping track of existing Entities.
+ * The `IEntityRepository` is the central storage for keeping track of existing Entities.
  * It provides basic CRUD functionality.
  */
 export interface IEntityRepository {
-    has(type: EntityTypeUid, uid: EntityUid): boolean;
-    get<TEntity extends IEntity>(type: EntityTypeUid, uid: EntityUid): TEntity;
-    getWithTime<TEntity extends IEntity>(type: EntityTypeUid, uid: EntityUid): StoredEntity<TEntity>;
-    getAll<TEntity extends IEntity>(type: EntityTypeUid): TEntity[];
-    listAll(): StoredEntity<IEntity>[];
+    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(type: EntityTypeUid, uid: EntityUid): void;
+    delete(proxy: IEntityProxy): void;
     clear(entityType: EntityTypeUid): void;
-    onEntitySetCallback?: (entity: IEntity) => void;
-    onEntityDeletedCallback?: (entity: IEntity) => void;
 }

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

@@ -1,8 +1,8 @@
-import { IEntityProxy } from "./entity-proxy";
+import { IEntityProxy } from "./entity-proxies";
 /**
- * The Entity Scheduler is the main way of scheduling Entity Updates on a Time Interval.
- * It usually reads the Entities from the Entity Repository,
- * and uses the Entity Update Queue to enqueue Entity updates.
+ * 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;

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

@@ -0,0 +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;
+}

package/dist/entities/entity-snapshot.js

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

package/dist/entities/entity-snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-snapshot.js","sourceRoot":"","sources":["../../src/entities/entity-snapshot.ts"],"names":[],"mappings":""}

package/dist/entities/entity.d.ts

@@ -1,17 +1,31 @@
 import { IdentityComponent } from "../components/identity-component";
 import { ComponentTypeUid, IComponent } from "../components/component";
-import { IEntityProxy } from "./entity-proxy";
+import { IEntityProxy } from "./entity-proxies";
 export declare type EntityTypeUid = string | number;
 export declare 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;
 }
 /**
- * An Entity is a container of Components and Entity Proxies. Only Systems can manipulate the internal state of the Entity.
+ * 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/index.d.ts

@@ -2,10 +2,11 @@ export * from './components/component';
 export * from './components/identity-component';
 export * from './entities/entity';
 export * from './entities/entity-events';
-export * from './entities/entity-proxy';
+export * from './entities/entity-proxies';
 export * from './entities/entity-queue';
 export * from './entities/entity-repository';
 export * from './entities/entity-scheduler';
+export * from './entities/entity-snapshot';
 export * from './factories/context-factory';
 export * from './factories/pipeline-factory';
 export * from './factories/runtime-factory';
@@ -21,6 +22,7 @@ export * from './systems/context/system-context-events';
 export * from './systems/context/system-context-proxies';
 export * from './systems/context/system-context-repository';
 export * from './systems/context/system-context-scheduler';
+export * from './systems/context/system-context-snapshot';
 export * from './systems/runtime/systems-runtime-context';
 export * from './systems/runtime/systems-runtime-middleware';
 export * from './systems/system-pipeline-middleware';
@@ -28,5 +30,6 @@ export * from './systems/system-pipeline-context';
 export * from './systems/system-pipeline-type';
 export * from './systems/systems-module';
 export * from './systems/systems-runtime';
+export * from './utils/json-serializer';
 export * from './utils/performance-timer';
 export * from './utils/types';

package/dist/index.js

@@ -18,10 +18,11 @@ __exportStar(require("./components/component"), exports);
 __exportStar(require("./components/identity-component"), exports);
 __exportStar(require("./entities/entity"), exports);
 __exportStar(require("./entities/entity-events"), exports);
-__exportStar(require("./entities/entity-proxy"), exports);
+__exportStar(require("./entities/entity-proxies"), exports);
 __exportStar(require("./entities/entity-queue"), exports);
 __exportStar(require("./entities/entity-repository"), exports);
 __exportStar(require("./entities/entity-scheduler"), exports);
+__exportStar(require("./entities/entity-snapshot"), exports);
 __exportStar(require("./factories/context-factory"), exports);
 __exportStar(require("./factories/pipeline-factory"), exports);
 __exportStar(require("./factories/runtime-factory"), exports);
@@ -37,6 +38,7 @@ __exportStar(require("./systems/context/system-context-events"), exports);
 __exportStar(require("./systems/context/system-context-proxies"), exports);
 __exportStar(require("./systems/context/system-context-repository"), exports);
 __exportStar(require("./systems/context/system-context-scheduler"), exports);
+__exportStar(require("./systems/context/system-context-snapshot"), exports);
 __exportStar(require("./systems/runtime/systems-runtime-context"), exports);
 __exportStar(require("./systems/runtime/systems-runtime-middleware"), exports);
 __exportStar(require("./systems/system-pipeline-middleware"), exports);
@@ -44,6 +46,7 @@ __exportStar(require("./systems/system-pipeline-context"), exports);
 __exportStar(require("./systems/system-pipeline-type"), exports);
 __exportStar(require("./systems/systems-module"), exports);
 __exportStar(require("./systems/systems-runtime"), exports);
+__exportStar(require("./utils/json-serializer"), exports);
 __exportStar(require("./utils/performance-timer"), exports);
 __exportStar(require("./utils/types"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yDAAsC;AACtC,kEAA+C;AAE/C,oDAAiC;AACjC,2DAAwC;AACxC,0DAAuC;AACvC,0DAAuC;AACvC,+DAA4C;AAC5C,8DAA2C;AAE3C,8DAA2C;AAC3C,+DAA4C;AAC5C,8DAA2C;AAE3C,6DAA0C;AAC1C,2DAAwC;AACxC,2DAAwC;AAExC,yDAAsC;AACtC,gEAA6C;AAC7C,8DAA2C;AAC3C,uDAAoC;AACpC,4DAAyC;AAEzC,0EAAuD;AACvD,2EAAwD;AACxD,8EAA2D;AAC3D,6EAA0D;AAE1D,4EAAyD;AACzD,+EAA4D;AAE5D,uEAAoD;AACpD,oEAAiD;AACjD,iEAA8C;AAC9C,2DAAwC;AACxC,4DAAyC;AAEzC,4DAAyC;AACzC,gDAA6B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yDAAsC;AACtC,kEAA+C;AAE/C,oDAAiC;AACjC,2DAAwC;AACxC,4DAAyC;AACzC,0DAAuC;AACvC,+DAA4C;AAC5C,8DAA2C;AAC3C,6DAA0C;AAE1C,8DAA2C;AAC3C,+DAA4C;AAC5C,8DAA2C;AAE3C,6DAA0C;AAC1C,2DAAwC;AACxC,2DAAwC;AAExC,yDAAsC;AACtC,gEAA6C;AAC7C,8DAA2C;AAC3C,uDAAoC;AACpC,4DAAyC;AAEzC,0EAAuD;AACvD,2EAAwD;AACxD,8EAA2D;AAC3D,6EAA0D;AAC1D,4EAAyD;AAEzD,4EAAyD;AACzD,+EAA4D;AAE5D,uEAAoD;AACpD,oEAAiD;AACjD,iEAA8C;AAC9C,2DAAwC;AACxC,4DAAyC;AAEzC,0DAAuC;AACvC,4DAAyC;AACzC,gDAA6B"}

package/dist/systems/context/system-context-events.d.ts

@@ -1,5 +1,5 @@
 import { EntityEventUid, IEntityEvent, IEventData } from "../../entities/entity-events";
-import { IEntityProxy } from "../../entities/entity-proxy";
+import { IEntityProxy } from "../../entities/entity-proxies";
 /**
  * The ISystemContextEvents is the access point for Event related APIs.
  * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.

package/dist/systems/context/system-context-proxies.d.ts

@@ -1,5 +1,5 @@
 import { EntityTypeUid } from "../../entities/entity";
-import { IEntityProxy } from "../../entities/entity-proxy";
+import { IEntityProxy } from "../../entities/entity-proxies";
 /**
  * The ISystemContextProxies is the access point for EntityProxy related APIs.
  * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.

package/dist/systems/context/system-context-repository.d.ts

@@ -1,12 +1,13 @@
 import { EntityTypeUid, IEntityModel, IEntity } from "../../entities/entity";
-import { IEntityEvent, IEventData } from "../../entities/entity-events";
-import { EntityProxy, IEntityProxy } from "../../entities/entity-proxy";
+import { EntityProxy, IEntityProxy } from "../../entities/entity-proxies";
+import { IEntitySnapshot } from "../../entities/entity-snapshot";
 /**
- * The ISystemContextRepository is the access point for EntityRepository related APIs.
- * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.
+ * The `ISystemContextRepository` is the access point for the `IEntityRepository` related APIs.
+ *
+ * The access is made in an `ISystemMiddleware` through the provided `ISystemPipelineContext`.
  */
 export interface ISystemContextRepository {
-    addEntity(entityType: EntityTypeUid, model: IEntityModel, events?: IEntityEvent<IEventData>[]): void;
+    addEntity(entityType: EntityTypeUid, model: IEntityModel, snapshot?: IEntitySnapshot): void;
     getEntity<TEntity extends IEntity>(proxy: EntityProxy<TEntity>): TEntity;
     updateEntity(target?: IEntityProxy): void;
     removeEntity(target: IEntityProxy): void;

package/dist/systems/context/system-context-scheduler.d.ts

@@ -1,4 +1,4 @@
-import { IEntityProxy } from "../../entities/entity-proxy";
+import { IEntityProxy } from "../../entities/entity-proxies";
 /**
  * The ISystemContextRepository is the access point for Scheduler related APIs.
  * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.

package/dist/systems/context/system-context-snapshot.d.ts

@@ -0,0 +1,10 @@
+import { IEntitySnapshot } from "../../entities/entity-snapshot";
+/**
+ * The ISystemContextSnapshot is the access point for Snapshot related APIs.
+ * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.
+ */
+export interface ISystemContextSnapshot {
+    readonly appliedSnapshot: IEntitySnapshot;
+    applySnapshot(snapshot: IEntitySnapshot): void;
+    createSnapshot(): IEntitySnapshot;
+}

package/dist/systems/context/system-context-snapshot.js

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

package/dist/systems/context/system-context-snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-context-snapshot.js","sourceRoot":"","sources":["../../../src/systems/context/system-context-snapshot.ts"],"names":[],"mappings":""}

package/dist/systems/system-pipeline-context.d.ts

@@ -3,6 +3,7 @@ import { ISystemContextEvents } from "./context/system-context-events";
 import { ISystemContextProxies } from "./context/system-context-proxies";
 import { ISystemContextRepository } from "./context/system-context-repository";
 import { ISystemContextScheduler } from "./context/system-context-scheduler";
+import { ISystemContextSnapshot } from "./context/system-context-snapshot";
 /**
  * The ISystemPipelineContext is the Context passed to a SystemMiddleware as part of the Pipeline Dispatch.
  * It's an abstraction layer so that the Middleware code won't have explicit dependencies on other parts of the ECS.
@@ -16,4 +17,5 @@ export interface ISystemPipelineContext<TEntity extends IEntity> {
     readonly proxies: Readonly<ISystemContextProxies>;
     readonly repository: Readonly<ISystemContextRepository>;
     readonly scheduler: Readonly<ISystemContextScheduler>;
+    readonly snapshot: Readonly<ISystemContextSnapshot>;
 }

package/dist/systems/systems-runtime.d.ts

@@ -1,6 +1,5 @@
-import { EntityTypeUid, IEntity } from "../entities/entity";
+import { IEntityUpdate } from "../entities/entity-queue";
 import { IRuntimeResult } from "../runtime/runtime-result";
-import { ISystemsModule } from "./systems-module";
 /**
  * The System Runtime allows running a loop of Ticks.
  *
@@ -10,13 +9,8 @@ import { ISystemsModule } from "./systems-module";
  */
 export interface ISystemsRuntime {
     /**
-     * Allows registering the SystemsModule that will be triggered for any EntityUpdate for the given EntityType.
-     * @param entityType The EntityType this module will be registered for.
-     * @param module The Module implementation that will be triggered when executing updates for the given EntityType.
+     * The method should trigger the SystemsModule logic for the provided IEntityUpdate.
+     * If no EntityUpdate is given, the SystemRuntime implementation can choose to dequeue one from the IEntityUpdateQueue.
      */
-    registerModule<TEntity extends IEntity>(entityType: EntityTypeUid, module: ISystemsModule<TEntity>): void;
-    /**
-     * The method allows for an Unit of Work implementation, and returns the remaining quantity of items scheduled to be processed next.
-     */
-    runTick(): IRuntimeResult | Promise<IRuntimeResult>;
+    runTick(update?: IEntityUpdate): IRuntimeResult | Promise<IRuntimeResult>;
 }

package/dist/utils/json-serializer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A custom `IJsonSerializer` implementation can provide different ways of serializing objects.
+ */
+export interface IJsonSerializer {
+    serializeCustom(value: object): string;
+    parseCustom<TObject>(text: string): TObject;
+}

package/dist/utils/json-serializer.js

@@ -0,0 +1,4 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=json-serializer.js.map

package/dist/utils/json-serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-serializer.js","sourceRoot":"","sources":["../../src/utils/json-serializer.ts"],"names":[],"mappings":";AAAA,uDAAuD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awesome-ecs/abstract",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "A comprehensive Entity-Component-System (ECS) Architecture implementation. Abstract components.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -8,7 +8,7 @@
     "dist"
   ],
   "devDependencies": {
-    "typescript": "^4.7.4"
+    "typescript": "^4.8.2"
   },
   "scripts": {
     "build": "rimraf ./dist && npx tsc --build"
@@ -32,5 +32,5 @@
     "url": "https://github.com/andreicojocaru/awesome-ecs/issues"
   },
   "homepage": "https://github.com/andreicojocaru/awesome-ecs#readme",
-  "gitHead": "866b983e2f2bf56d3d6c5646c38c65429a5a7259"
+  "gitHead": "592915c8f5a8c76360ad6459a5bad0e3995bcba9"
 }

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

@@ -1,14 +0,0 @@
-import { EntityTypeUid, EntityUid, IEntity } from "./entity";
-/**
- * Represents a pointer to another Entity.
- */
-export interface IEntityProxy {
-    readonly entityType: EntityTypeUid;
-    readonly entityUid: EntityUid;
-}
-/**
- * A utility extension of IEntityProxy.
- * Useful for providing Type information when using the IEntityProxy.
- */
-export interface EntityProxy<TEntity extends IEntity> extends IEntityProxy {
-}

package/dist/entities/entity-proxy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"entity-proxy.js","sourceRoot":"","sources":["../../src/entities/entity-proxy.ts"],"names":[],"mappings":""}