@awesome-ecs/abstract 0.15.0 → 0.18.0

package/dist/components/index.cjs

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/index.ts
+var components_exports = {};
+__export(components_exports, {
+  BasicComponentType: () => BasicComponentType
+});
+module.exports = __toCommonJS(components_exports);
+
+// src/components/identity-component.ts
+var BasicComponentType = /* @__PURE__ */ ((BasicComponentType2) => {
+  BasicComponentType2["identity"] = "identity";
+  return BasicComponentType2;
+})(BasicComponentType || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BasicComponentType
+});
+//# sourceMappingURL=index.cjs.map

package/dist/components/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/components/index.ts","../../src/components/identity-component.ts"],"sourcesContent":["export * from \"./component\";\nexport * from \"./identity-component\";\n","import { IComponent } from \"./component\";\nimport { EntityTypeUid, IEntityModel } from \"../entities/entity\";\nimport { Immutable } from \"../utils/types\";\n\nexport enum BasicComponentType {\n  identity = \"identity\",\n}\n\n/**\n * The `IdentityComponent` contains basic information regarding what makes the current Entity unique.\n */\nexport interface IdentityComponent<TModel extends IEntityModel> extends IComponent {\n  /**\n   * The Entity Type that defines what Category type the Entity is part of. There can be multiple Entities sharing the same EntityType.\n   */\n  readonly entityType: EntityTypeUid;\n\n  /**\n   * The Model is the basic information needed to create an `IEntity` when it's first initialized.\n   * It provides a first snapshot of information needed for the successful creation of an Entity instance.\n   */\n  readonly model: Immutable<TModel>;\n\n  /**\n   * Keeps track when the Entity's systems have ran last. Useful to calculate the `DeltaTime` between runs.\n   */\n  readonly lastUpdated?: Date;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACIO,IAAK,qBAAL,kBAAKA,wBAAL;AACL,EAAAA,oBAAA,cAAW;AADD,SAAAA;AAAA,GAAA;","names":["BasicComponentType"]}

package/dist/components/index.d.cts

@@ -0,0 +1,2 @@
+export { B as BasicComponentType, C as ComponentTypeUid, g as IComponent, f as IdentityComponent } from '../index-DK2CXVZ8.cjs';
+import '../types-BNwBqRWY.cjs';

package/dist/components/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./component";
-export * from "./identity-component";
+export { B as BasicComponentType, C as ComponentTypeUid, g as IComponent, f as IdentityComponent } from '../index-BPDsRt_F.js';
+import '../types-BNwBqRWY.js';

package/dist/components/index.js

@@ -1,19 +1,9 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+// src/components/identity-component.ts
+var BasicComponentType = /* @__PURE__ */ ((BasicComponentType2) => {
+  BasicComponentType2["identity"] = "identity";
+  return BasicComponentType2;
+})(BasicComponentType || {});
+export {
+  BasicComponentType
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./component"), exports);
-__exportStar(require("./identity-component"), exports);
 //# sourceMappingURL=index.js.map

package/dist/components/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/components/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,uDAAqC"}
+{"version":3,"sources":["../../src/components/identity-component.ts"],"sourcesContent":["import { IComponent } from \"./component\";\nimport { EntityTypeUid, IEntityModel } from \"../entities/entity\";\nimport { Immutable } from \"../utils/types\";\n\nexport enum BasicComponentType {\n  identity = \"identity\",\n}\n\n/**\n * The `IdentityComponent` contains basic information regarding what makes the current Entity unique.\n */\nexport interface IdentityComponent<TModel extends IEntityModel> extends IComponent {\n  /**\n   * The Entity Type that defines what Category type the Entity is part of. There can be multiple Entities sharing the same EntityType.\n   */\n  readonly entityType: EntityTypeUid;\n\n  /**\n   * The Model is the basic information needed to create an `IEntity` when it's first initialized.\n   * It provides a first snapshot of information needed for the successful creation of an Entity instance.\n   */\n  readonly model: Immutable<TModel>;\n\n  /**\n   * Keeps track when the Entity's systems have ran last. Useful to calculate the `DeltaTime` between runs.\n   */\n  readonly lastUpdated?: Date;\n}\n"],"mappings":";AAIO,IAAK,qBAAL,kBAAKA,wBAAL;AACL,EAAAA,oBAAA,cAAW;AADD,SAAAA;AAAA,GAAA;","names":["BasicComponentType"]}

package/dist/entities/index.cjs

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/entities/index.ts
+var entities_exports = {};
+__export(entities_exports, {
+  EntityUpdateType: () => EntityUpdateType
+});
+module.exports = __toCommonJS(entities_exports);
+
+// src/entities/entity-queue.ts
+var EntityUpdateType = /* @__PURE__ */ ((EntityUpdateType2) => {
+  EntityUpdateType2["update"] = "update";
+  EntityUpdateType2["remove"] = "remove";
+  return EntityUpdateType2;
+})(EntityUpdateType || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EntityUpdateType
+});
+//# sourceMappingURL=index.cjs.map

package/dist/entities/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/entities/index.ts","../../src/entities/entity-queue.ts"],"sourcesContent":["export * from \"./entity\";\nexport * from \"./entity-events\";\nexport * from \"./entity-proxies\";\nexport * from \"./entity-queue\";\nexport * from \"./entity-repository\";\nexport * from \"./entity-scheduler\";\nexport * from \"./entity-snapshot\";\n","import { IEntityModel } from \"./entity\";\nimport { IEntityProxy } from \"./entity-proxies\";\nimport { IEntitySnapshot } from \"./entity-snapshot\";\n\n/**\n * The `EntityUpdateType` specifies whether the current should `update` or `remove` the Entity.\n */\nexport enum EntityUpdateType {\n  update = \"update\",\n  remove = \"remove\",\n}\n\n/**\n * The `IEntityUpdate` represents an Entity update that should be applied over an (existing) Entity.\n */\nexport interface IEntityUpdate {\n  type: EntityUpdateType;\n  entity: IEntityProxy;\n  model?: IEntityModel;\n  snapshot?: IEntitySnapshot;\n}\n\n/**\n * The `IEntityUpdateQueue` is the main mechanism to queue and retrieve `EntityUpdate` instances.\n *\n * The interface can be implemented using a simple queue mechanism, or perhaps, a Priority Queue.\n */\nexport interface IEntityUpdateQueue {\n  readonly size: number;\n\n  enqueue(change: IEntityUpdate): void;\n  dequeue(): IEntityUpdate;\n\n  peek(): IEntityUpdate;\n  clear(): void;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACOO,IAAK,mBAAL,kBAAKA,sBAAL;AACL,EAAAA,kBAAA,YAAS;AACT,EAAAA,kBAAA,YAAS;AAFC,SAAAA;AAAA,GAAA;","names":["EntityUpdateType"]}

package/dist/entities/index.d.cts

@@ -0,0 +1,17 @@
+import { I as IEntityProxy } from '../index-DK2CXVZ8.cjs';
+export { d as EntityProxy, E as EntityTypeUid, a as EntityUid, c as IEntity, b as IEntityModel, e as IEntityProxiesManager } from '../index-DK2CXVZ8.cjs';
+export { a as EntityEventSubscriptionFilter, E as EntityEventUid, e as EntityUpdateType, b as IEntityEvent, d as IEntityEventsDispatcher, c as IEntityEventsManager, h as IEntityRepository, i as IEntitySnapshot, j as IEntitySnapshotProvider, f as IEntityUpdate, g as IEntityUpdateQueue, I as IEventData } from '../entity-repository-awW_H993.cjs';
+import '../types-BNwBqRWY.cjs';
+
+/**
+ * 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.
+ */
+interface IEntityScheduler {
+    schedule(entityProxy: IEntityProxy, intervalMs?: number): void;
+    remove(entityProxy: IEntityProxy): void;
+    has(entityProxy: IEntityProxy): boolean;
+}
+
+export { IEntityProxy, type IEntityScheduler };

package/dist/entities/index.d.ts

@@ -1,7 +1,17 @@
-export * from "./entity";
-export * from "./entity-events";
-export * from "./entity-proxies";
-export * from "./entity-queue";
-export * from "./entity-repository";
-export * from "./entity-scheduler";
-export * from "./entity-snapshot";
+import { I as IEntityProxy } from '../index-BPDsRt_F.js';
+export { d as EntityProxy, E as EntityTypeUid, a as EntityUid, c as IEntity, b as IEntityModel, e as IEntityProxiesManager } from '../index-BPDsRt_F.js';
+export { a as EntityEventSubscriptionFilter, E as EntityEventUid, e as EntityUpdateType, b as IEntityEvent, d as IEntityEventsDispatcher, c as IEntityEventsManager, h as IEntityRepository, i as IEntitySnapshot, j as IEntitySnapshotProvider, f as IEntityUpdate, g as IEntityUpdateQueue, I as IEventData } from '../entity-repository-Bu6rH-m5.js';
+import '../types-BNwBqRWY.js';
+
+/**
+ * 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.
+ */
+interface IEntityScheduler {
+    schedule(entityProxy: IEntityProxy, intervalMs?: number): void;
+    remove(entityProxy: IEntityProxy): void;
+    has(entityProxy: IEntityProxy): boolean;
+}
+
+export { IEntityProxy, type IEntityScheduler };

package/dist/entities/index.js

@@ -1,24 +1,10 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+// src/entities/entity-queue.ts
+var EntityUpdateType = /* @__PURE__ */ ((EntityUpdateType2) => {
+  EntityUpdateType2["update"] = "update";
+  EntityUpdateType2["remove"] = "remove";
+  return EntityUpdateType2;
+})(EntityUpdateType || {});
+export {
+  EntityUpdateType
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./entity"), exports);
-__exportStar(require("./entity-events"), exports);
-__exportStar(require("./entity-proxies"), exports);
-__exportStar(require("./entity-queue"), exports);
-__exportStar(require("./entity-repository"), exports);
-__exportStar(require("./entity-scheduler"), exports);
-__exportStar(require("./entity-snapshot"), exports);
 //# sourceMappingURL=index.js.map

package/dist/entities/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/entities/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,kDAAgC;AAChC,mDAAiC;AACjC,iDAA+B;AAC/B,sDAAoC;AACpC,qDAAmC;AACnC,oDAAkC"}
+{"version":3,"sources":["../../src/entities/entity-queue.ts"],"sourcesContent":["import { IEntityModel } from \"./entity\";\nimport { IEntityProxy } from \"./entity-proxies\";\nimport { IEntitySnapshot } from \"./entity-snapshot\";\n\n/**\n * The `EntityUpdateType` specifies whether the current should `update` or `remove` the Entity.\n */\nexport enum EntityUpdateType {\n  update = \"update\",\n  remove = \"remove\",\n}\n\n/**\n * The `IEntityUpdate` represents an Entity update that should be applied over an (existing) Entity.\n */\nexport interface IEntityUpdate {\n  type: EntityUpdateType;\n  entity: IEntityProxy;\n  model?: IEntityModel;\n  snapshot?: IEntitySnapshot;\n}\n\n/**\n * The `IEntityUpdateQueue` is the main mechanism to queue and retrieve `EntityUpdate` instances.\n *\n * The interface can be implemented using a simple queue mechanism, or perhaps, a Priority Queue.\n */\nexport interface IEntityUpdateQueue {\n  readonly size: number;\n\n  enqueue(change: IEntityUpdate): void;\n  dequeue(): IEntityUpdate;\n\n  peek(): IEntityUpdate;\n  clear(): void;\n}\n"],"mappings":";AAOO,IAAK,mBAAL,kBAAKA,sBAAL;AACL,EAAAA,kBAAA,YAAS;AACT,EAAAA,kBAAA,YAAS;AAFC,SAAAA;AAAA,GAAA;","names":["EntityUpdateType"]}

package/dist/entity-repository-Bu6rH-m5.d.ts

@@ -0,0 +1,119 @@
+import { I as IEntityProxy, f as IdentityComponent, b as IEntityModel, g as IComponent, c as IEntity, E as EntityTypeUid } from './index-BPDsRt_F.js';
+
+type EntityEventUid = string | number;
+type EntityEventSubscriptionFilter = (event: IEntityEvent<IEventData>) => boolean;
+/**
+ * The `IEventData` contains the event-specific state. At the very least, it contains the `Event Unique Identifier`.
+ */
+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`.
+ */
+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).
+ */
+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.
+ */
+interface IEntityEventsDispatcher {
+    dispatchEvent(event: IEntityEvent<IEventData>, ...targets: IEntityProxy[]): void;
+    dispatchEvents(events: IEntityEvent<IEventData>[], ...targets: IEntityProxy[]): void;
+}
+
+/**
+ * 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).
+ */
+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`.
+ */
+interface IEntitySnapshotProvider {
+    applySnapshot(entity: IEntity, snapshot: IEntitySnapshot): void;
+    createSnapshot(entity: IEntity): IEntitySnapshot;
+}
+
+/**
+ * The `EntityUpdateType` specifies whether the current should `update` or `remove` the Entity.
+ */
+declare enum EntityUpdateType {
+    update = "update",
+    remove = "remove"
+}
+/**
+ * The `IEntityUpdate` represents an Entity update that should be applied over an (existing) Entity.
+ */
+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.
+ */
+interface IEntityUpdateQueue {
+    readonly size: number;
+    enqueue(change: IEntityUpdate): void;
+    dequeue(): IEntityUpdate;
+    peek(): IEntityUpdate;
+    clear(): void;
+}
+
+/**
+ * The `IEntityRepository` is the central storage for keeping track of existing Entities.
+ * It provides basic CRUD functionality.
+ */
+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;
+}
+
+export { type EntityEventUid as E, type IEventData as I, type EntityEventSubscriptionFilter as a, type IEntityEvent as b, type IEntityEventsManager as c, type IEntityEventsDispatcher as d, EntityUpdateType as e, type IEntityUpdate as f, type IEntityUpdateQueue as g, type IEntityRepository as h, type IEntitySnapshot as i, type IEntitySnapshotProvider as j };

package/dist/entity-repository-awW_H993.d.cts

@@ -0,0 +1,119 @@
+import { I as IEntityProxy, f as IdentityComponent, b as IEntityModel, g as IComponent, c as IEntity, E as EntityTypeUid } from './index-DK2CXVZ8.cjs';
+
+type EntityEventUid = string | number;
+type EntityEventSubscriptionFilter = (event: IEntityEvent<IEventData>) => boolean;
+/**
+ * The `IEventData` contains the event-specific state. At the very least, it contains the `Event Unique Identifier`.
+ */
+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`.
+ */
+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).
+ */
+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.
+ */
+interface IEntityEventsDispatcher {
+    dispatchEvent(event: IEntityEvent<IEventData>, ...targets: IEntityProxy[]): void;
+    dispatchEvents(events: IEntityEvent<IEventData>[], ...targets: IEntityProxy[]): void;
+}
+
+/**
+ * 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).
+ */
+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`.
+ */
+interface IEntitySnapshotProvider {
+    applySnapshot(entity: IEntity, snapshot: IEntitySnapshot): void;
+    createSnapshot(entity: IEntity): IEntitySnapshot;
+}
+
+/**
+ * The `EntityUpdateType` specifies whether the current should `update` or `remove` the Entity.
+ */
+declare enum EntityUpdateType {
+    update = "update",
+    remove = "remove"
+}
+/**
+ * The `IEntityUpdate` represents an Entity update that should be applied over an (existing) Entity.
+ */
+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.
+ */
+interface IEntityUpdateQueue {
+    readonly size: number;
+    enqueue(change: IEntityUpdate): void;
+    dequeue(): IEntityUpdate;
+    peek(): IEntityUpdate;
+    clear(): void;
+}
+
+/**
+ * The `IEntityRepository` is the central storage for keeping track of existing Entities.
+ * It provides basic CRUD functionality.
+ */
+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;
+}
+
+export { type EntityEventUid as E, type IEventData as I, type EntityEventSubscriptionFilter as a, type IEntityEvent as b, type IEntityEventsManager as c, type IEntityEventsDispatcher as d, EntityUpdateType as e, type IEntityUpdate as f, type IEntityUpdateQueue as g, type IEntityRepository as h, type IEntitySnapshot as i, type IEntitySnapshotProvider as j };

package/dist/factories/index.cjs

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/factories/index.ts
+var factories_exports = {};
+module.exports = __toCommonJS(factories_exports);
+//# sourceMappingURL=index.cjs.map

package/dist/factories/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/factories/index.ts"],"sourcesContent":["export * from \"./context-factory\";\nexport * from \"./pipeline-factory\";\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/factories/index.d.cts

@@ -0,0 +1,27 @@
+import { c as IEntity } from '../index-DK2CXVZ8.cjs';
+import { I as ISystemsRuntimeContext, a as ISystemContext } from '../systems-runtime-context-Cq4vxbHX.cjs';
+import { I as IPipelineContext, M as MiddlewareResult, a as IPipeline } from '../pipeline-BowCAITe.cjs';
+import '../types-BNwBqRWY.cjs';
+import '../entity-repository-awW_H993.cjs';
+import '../utils/index.cjs';
+import '../performance-timer-XvdCbcAE.cjs';
+
+/**
+ * The IContextFactory can be used as an abstraction layer to quickly create Pipeline Contexts,
+ * without having to manually resolve all of their dependencies.
+ */
+interface IContextFactory {
+    createRuntimeContext<TEntity extends IEntity>(): ISystemsRuntimeContext<TEntity>;
+}
+
+/**
+ * The PipelineFactory can be used as an abstraction layer to quickly create IPipeline objects,
+ * without having to manually resolve all of their dependencies.
+ */
+interface IPipelineFactory {
+    createPipeline<TContext extends IPipelineContext, TResult = MiddlewareResult>(name?: string): IPipeline<TContext, TResult>;
+    createSystemsPipeline<TEntity extends IEntity, TResult = MiddlewareResult>(name?: string): IPipeline<ISystemContext<TEntity>, TResult>;
+    createRuntimePipeline<TEntity extends IEntity, TResult = MiddlewareResult>(name?: string): IPipeline<ISystemsRuntimeContext<TEntity>, TResult>;
+}
+
+export type { IContextFactory, IPipelineFactory };

package/dist/factories/index.d.ts

@@ -1,2 +1,27 @@
-export * from "./context-factory";
-export * from "./pipeline-factory";
+import { c as IEntity } from '../index-BPDsRt_F.js';
+import { I as ISystemsRuntimeContext, a as ISystemContext } from '../systems-runtime-context-DjppCqs4.js';
+import { I as IPipelineContext, M as MiddlewareResult, a as IPipeline } from '../pipeline-D43CXxWG.js';
+import '../types-BNwBqRWY.js';
+import '../entity-repository-Bu6rH-m5.js';
+import '../utils/index.js';
+import '../performance-timer-XvdCbcAE.js';
+
+/**
+ * The IContextFactory can be used as an abstraction layer to quickly create Pipeline Contexts,
+ * without having to manually resolve all of their dependencies.
+ */
+interface IContextFactory {
+    createRuntimeContext<TEntity extends IEntity>(): ISystemsRuntimeContext<TEntity>;
+}
+
+/**
+ * The PipelineFactory can be used as an abstraction layer to quickly create IPipeline objects,
+ * without having to manually resolve all of their dependencies.
+ */
+interface IPipelineFactory {
+    createPipeline<TContext extends IPipelineContext, TResult = MiddlewareResult>(name?: string): IPipeline<TContext, TResult>;
+    createSystemsPipeline<TEntity extends IEntity, TResult = MiddlewareResult>(name?: string): IPipeline<ISystemContext<TEntity>, TResult>;
+    createRuntimePipeline<TEntity extends IEntity, TResult = MiddlewareResult>(name?: string): IPipeline<ISystemsRuntimeContext<TEntity>, TResult>;
+}
+
+export type { IContextFactory, IPipelineFactory };

package/dist/factories/index.js

@@ -1,19 +1 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./context-factory"), exports);
-__exportStar(require("./pipeline-factory"), exports);
 //# sourceMappingURL=index.js.map

package/dist/factories/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/factories/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAkC;AAClC,qDAAmC"}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}