@awesome-ecs/abstract 0.20.2 → 0.21.1

package/README.md

@@ -5,6 +5,30 @@
 The Entity-Component-System is a well-known Architecture type used for responsive, complex applications, not only restricted to the Web.
 It's mostly associated with Game Engines, because of it's way of segregating Behavior from State, and allowing fine-control of the Runtime.
 
+## Real-World Usage Patterns
+
+Based on the analysis of real-world usage in project-anchor, here are the key patterns that have proven effective:
+
+### Component Patterns
+
+- **Component Type Enumeration**: Components are identified using a `ComponentType` enum, making component retrieval and identification type-safe and consistent
+- **Specialized Component Focus**: Components focus on specific concerns (e.g., `CoordinatesComponent`, `RenderingComponent`, `AssetsComponent`)
+- **Component Serialization**: Components can be marked with `isSerializable` to control which components get synchronized with external systems
+- **Component Factories**: Using factory patterns to create and configure components with standard defaults
+
+### Entity Patterns
+
+- **Type-Safe Entity Access**: Entities expose strongly-typed getters for their components
+- **Entity Proxies**: Entities use proxy objects to reference other entities, maintaining relationships while avoiding direct dependencies
+- **Entity Type Enumeration**: Entities are categorized using an `EntityType` enum
+- **Entity Hierarchy**: Entities often form hierarchical relationships (e.g., scene → grid → tile)
+
+### System Organization
+
+- **System Pipelines**: Systems are organized into distinct pipelines (initialize, update, render) that execute in sequence
+- **System Modules**: Systems are grouped in modules that target specific entity types
+- **Middleware Approach**: Systems implement the middleware pattern for clean, composable behavior
+
 ## Building blocks
 
 ### Entities
@@ -97,3 +121,108 @@ The Render Systems can be skipped from the Runtime, if needed. That can be usefu
 The Dispatch Systems are built-in Systems in the Awesome ECS, and will take care of Dispatching Actions, Scheduling Entity updates, or synchronizing the Entity Repository with the latest Entity State in the current Context.
 
 The Dispatch Systems, as well as any other Runtime Stage, can be extended as needed by registering more System Middlewares in the Stage Pipeline.
+
+## Integration Examples
+
+### Component Definition Example
+
+```typescript
+import { IComponent } from "@awesome-ecs/abstract";
+import { ComponentType } from "../abstract/components/component-type";
+
+export class CoordinatesComponent implements IComponent {
+  readonly componentType = ComponentType.coordinates;
+  readonly isSerializable = false;
+
+  // Component state
+  private coordinates: GridCoordinates;
+
+  // Component methods
+  setTileRadius(value: SpaceMeasurement) {
+    this.coordinates = new GridCoordinates(value);
+  }
+  
+  getCenterPointFor(position: GridPosition): GridPoint {
+    return this.coordinates.getCenterPointFor(position);
+  }
+}
+```
+
+### Entity Definition Example
+
+```typescript
+import { EntityBase } from "@awesome-ecs/core";
+import { EntityProxy, EntityUid, IEntityModel, IEntityProxy } from "@awesome-ecs/abstract";
+import { ComponentType } from "../abstract/components/component-type";
+import { EntityType } from "../abstract/entities/entity-type";
+
+export class GridEntity extends EntityBase<GridModel> {
+  // Entity proxies for relationships
+  get sceneProxy(): EntityProxy<SceneEntity> {
+    return this.getProxy(EntityType.scene);
+  }
+
+  get buildingProxies(): IterableIterator<EntityProxy<BuildingEntity>> {
+    return this.getProxies(EntityType.building);
+  }
+
+  // Component accessors
+  get coordinates(): CoordinatesComponent {
+    return this.getComponent(ComponentType.coordinates);
+  }
+
+  get rendering(): RenderingComponent<GridRenderingContext> {
+    return this.getComponent(ComponentType.rendering);
+  }
+}
+```
+
+### System Module Example
+
+```typescript
+import { SystemPipelineType } from "@awesome-ecs/abstract";
+import { LocalSystemsModuleBase } from "../abstract/systems/system-module-base";
+
+export class GridSystemsModule extends LocalSystemsModuleBase<GridEntity> {
+  constructor(
+    // Systems injected via dependency injection
+    gridContainerInitializerSystem: GridContainerInitializerSystem,
+    gridCoordinatesInitializerSystem: GridCoordinatesInitializerSystem,
+    gridPerimeterRenderingSystem: GridPerimeterRenderingSystem
+  ) {
+    super();
+
+    // Register systems for different pipeline stages
+    this.registerSystems(SystemPipelineType.initialize, [
+      gridContainerInitializerSystem,
+      gridCoordinatesInitializerSystem
+    ]);
+
+    this.registerSystems(SystemPipelineType.render, [
+      gridPerimeterRenderingSystem
+    ]);
+  }
+
+  // Entity factory method
+  protected initEntity(model: GridModel): GridEntity {
+    // Create and return entity instance
+    const entity = new GridEntity(
+      ComponentFactory.identity(EntityType.grid, model),
+      [
+        ComponentFactory.coordinates(),
+        ComponentFactory.rendering()
+      ],
+      [
+        // Entity relationships via proxies
+        model.parent,
+        {
+          entityType: EntityType.scene,
+          entityUid: IdGenerator.sceneUid(),
+        }
+      ]
+    );
+
+    return entity;
+  }
+}
+```

package/dist/components/index.cjs

@@ -1,35 +1,13 @@
-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);
+//#region src/components/identity-component.ts
+/**
+* The `BasicComponentType` enum defines the types of basic components available.
+*/
+let BasicComponentType = /* @__PURE__ */ function(BasicComponentType$1) {
+	BasicComponentType$1["identity"] = "identity";
+	return BasicComponentType$1;
+}({});
 
-// 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
-});
+//#endregion
+exports.BasicComponentType = BasicComponentType;
 //# sourceMappingURL=index.cjs.map

package/dist/components/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/components/index.ts","../../src/components/identity-component.ts"],"sourcesContent":["export * from './component';\nexport * from './identity-component';\n","import { EntityTypeUid, IEntityModel } from '../entities/entity';\nimport { Immutable } from '../utils/types';\nimport { IComponent } from './component';\n\n/**\n * The `BasicComponentType` enum defines the types of basic components available.\n */\nexport enum BasicComponentType {\n  identity = 'identity'\n}\n\n/**\n * IdentityComponent interface represents the basic information regarding what makes the current Entity unique.\n * It extends the IComponent interface.\n *\n * @template TModel - The type of the model that extends IEntityModel.\n */\nexport interface IdentityComponent<TModel extends IEntityModel> extends IComponent {\n  /**\n   * The Entity Type that defines what Category type the Entity is part of.\n   * 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   * @type {Immutable<TModel>}\n   */\n  readonly model: Immutable<TModel>;\n\n  /**\n   * Keeps track when the Entity's systems have ran last.\n   * Useful to calculate the `DeltaTime` between runs.\n   *\n   * @type {Date | undefined}\n   */\n  readonly lastUpdated?: Date;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACOO,IAAK,qBAAL,kBAAKA,wBAAL;AACL,EAAAA,oBAAA,cAAW;AADD,SAAAA;AAAA,GAAA;","names":["BasicComponentType"]}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/components/identity-component.ts"],"sourcesContent":["import { EntityTypeUid, IEntityModel } from '../entities/entity';\nimport { Immutable } from '../utils/types';\nimport { IComponent } from './component';\n\n/**\n * The `BasicComponentType` enum defines the types of basic components available.\n */\nexport enum BasicComponentType {\n  identity = 'identity'\n}\n\n/**\n * IdentityComponent interface represents the basic information regarding what makes the current Entity unique.\n * It extends the IComponent interface.\n *\n * @template TModel - The type of the model that extends IEntityModel.\n */\nexport interface IdentityComponent<TModel extends IEntityModel> extends IComponent {\n  /**\n   * The Entity Type that defines what Category type the Entity is part of.\n   * 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   * @type {Immutable<TModel>}\n   */\n  readonly model: Immutable<TModel>;\n\n  /**\n   * Keeps track when the Entity's systems have ran last.\n   * Useful to calculate the `DeltaTime` between runs.\n   *\n   * @type {Date | undefined}\n   */\n  readonly lastUpdated?: Date;\n}\n"],"mappings":";;;;;AAOA,IAAY,oEAAL;AACL;;AACD"}

package/dist/components/index.d.cts

@@ -1,2 +1,3 @@
-export { B as BasicComponentType, C as ComponentTypeUid, g as IComponent, f as IdentityComponent } from '../index-CnlpX7ys.cjs';
-import '../types-cZ-1lGPD.cjs';
+import { BasicComponentType, ComponentTypeUid, IComponent, IdentityComponent } from "../identity-component-BDWEtAXA.cjs";
+import "../types-DvzdpbLu.cjs";
+export { BasicComponentType, ComponentTypeUid, IComponent, IdentityComponent };

package/dist/components/index.d.ts

@@ -1,2 +1,3 @@
-export { B as BasicComponentType, C as ComponentTypeUid, g as IComponent, f as IdentityComponent } from '../index-B1KXekZD.js';
-import '../types-cZ-1lGPD.js';
+import { BasicComponentType, ComponentTypeUid, IComponent, IdentityComponent } from "../identity-component-CR1ULadR.js";
+import "../types-yh4pOGEm.js";
+export { BasicComponentType, ComponentTypeUid, IComponent, IdentityComponent };

package/dist/components/index.js

@@ -1,9 +1,12 @@
-// src/components/identity-component.ts
-var BasicComponentType = /* @__PURE__ */ ((BasicComponentType2) => {
-  BasicComponentType2["identity"] = "identity";
-  return BasicComponentType2;
-})(BasicComponentType || {});
-export {
-  BasicComponentType
-};
+//#region src/components/identity-component.ts
+/**
+* The `BasicComponentType` enum defines the types of basic components available.
+*/
+let BasicComponentType = /* @__PURE__ */ function(BasicComponentType$1) {
+	BasicComponentType$1["identity"] = "identity";
+	return BasicComponentType$1;
+}({});
+
+//#endregion
+export { BasicComponentType };
 //# sourceMappingURL=index.js.map

package/dist/components/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/components/identity-component.ts"],"sourcesContent":["import { EntityTypeUid, IEntityModel } from '../entities/entity';\nimport { Immutable } from '../utils/types';\nimport { IComponent } from './component';\n\n/**\n * The `BasicComponentType` enum defines the types of basic components available.\n */\nexport enum BasicComponentType {\n  identity = 'identity'\n}\n\n/**\n * IdentityComponent interface represents the basic information regarding what makes the current Entity unique.\n * It extends the IComponent interface.\n *\n * @template TModel - The type of the model that extends IEntityModel.\n */\nexport interface IdentityComponent<TModel extends IEntityModel> extends IComponent {\n  /**\n   * The Entity Type that defines what Category type the Entity is part of.\n   * 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   * @type {Immutable<TModel>}\n   */\n  readonly model: Immutable<TModel>;\n\n  /**\n   * Keeps track when the Entity's systems have ran last.\n   * Useful to calculate the `DeltaTime` between runs.\n   *\n   * @type {Date | undefined}\n   */\n  readonly lastUpdated?: Date;\n}\n"],"mappings":";AAOO,IAAK,qBAAL,kBAAKA,wBAAL;AACL,EAAAA,oBAAA,cAAW;AADD,SAAAA;AAAA,GAAA;","names":["BasicComponentType"]}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/components/identity-component.ts"],"sourcesContent":["import { EntityTypeUid, IEntityModel } from '../entities/entity';\nimport { Immutable } from '../utils/types';\nimport { IComponent } from './component';\n\n/**\n * The `BasicComponentType` enum defines the types of basic components available.\n */\nexport enum BasicComponentType {\n  identity = 'identity'\n}\n\n/**\n * IdentityComponent interface represents the basic information regarding what makes the current Entity unique.\n * It extends the IComponent interface.\n *\n * @template TModel - The type of the model that extends IEntityModel.\n */\nexport interface IdentityComponent<TModel extends IEntityModel> extends IComponent {\n  /**\n   * The Entity Type that defines what Category type the Entity is part of.\n   * 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   * @type {Immutable<TModel>}\n   */\n  readonly model: Immutable<TModel>;\n\n  /**\n   * Keeps track when the Entity's systems have ran last.\n   * Useful to calculate the `DeltaTime` between runs.\n   *\n   * @type {Date | undefined}\n   */\n  readonly lastUpdated?: Date;\n}\n"],"mappings":";;;;AAOA,IAAY,oEAAL;AACL;;AACD"}

package/dist/entities/index.cjs

@@ -1,36 +1,14 @@
-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);
+//#region src/entities/entity-queue.ts
+/**
+* The `EntityUpdateType` enum specifies whether the current Entity should be `updated` or `removed`.
+*/
+let EntityUpdateType = /* @__PURE__ */ function(EntityUpdateType$1) {
+	EntityUpdateType$1["update"] = "update";
+	EntityUpdateType$1["remove"] = "remove";
+	return EntityUpdateType$1;
+}({});
 
-// 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
-});
+//#endregion
+exports.EntityUpdateType = EntityUpdateType;
 //# sourceMappingURL=index.cjs.map

package/dist/entities/index.cjs.map

@@ -1 +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` enum specifies whether the current Entity should be `updated` or `removed`.\n */\nexport enum EntityUpdateType {\n  update = 'update',\n  remove = 'remove'\n}\n\n/**\n * The `IEntityUpdate` interface represents an Entity update that should be applied over an existing Entity.\n */\nexport interface IEntityUpdate {\n  /**\n   * The type of the update, which can be either `update` or `remove`.\n   */\n  type: EntityUpdateType;\n\n  /**\n   * The proxy of the Entity that needs to be updated.\n   */\n  entity: IEntityProxy;\n\n  /**\n   * Optional. The model of the Entity that needs to be updated.\n   */\n  model?: IEntityModel;\n\n  /**\n   * Optional. The snapshot of the Entity that needs to be updated.\n   */\n  snapshot?: IEntitySnapshot;\n}\n\n/**\n * The `IEntityUpdateQueue` interface 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  /**\n   * The number of `EntityUpdate` instances currently in the queue.\n   */\n  readonly size: number;\n\n  /**\n   * Adds an `EntityUpdate` instance to the end of the queue.\n   * @param change - The `EntityUpdate` instance to be added.\n   */\n  enqueue(change: IEntityUpdate): void;\n\n  /**\n   * Removes and returns the `EntityUpdate` instance at the front of the queue.\n   * @returns The `EntityUpdate` instance at the front of the queue.\n   */\n  dequeue(): IEntityUpdate;\n\n  /**\n   * Returns the `EntityUpdate` instance at the front of the queue without removing it.\n   * @returns The `EntityUpdate` instance at the front of the queue.\n   */\n  peek(): IEntityUpdate;\n\n  /**\n   * Removes all `EntityUpdate` instances from the queue.\n   */\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"]}
+{"version":3,"file":"index.cjs","names":[],"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` enum specifies whether the current Entity should be `updated` or `removed`.\n */\nexport enum EntityUpdateType {\n  update = 'update',\n  remove = 'remove'\n}\n\n/**\n * The `IEntityUpdate` interface represents an Entity update that should be applied over an existing Entity.\n */\nexport interface IEntityUpdate {\n  /**\n   * The type of the update, which can be either `update` or `remove`.\n   */\n  type: EntityUpdateType;\n\n  /**\n   * The proxy of the Entity that needs to be updated.\n   */\n  entity: IEntityProxy;\n\n  /**\n   * Optional. The model of the Entity that needs to be updated.\n   */\n  model?: IEntityModel;\n\n  /**\n   * Optional. The snapshot of the Entity that needs to be updated.\n   */\n  snapshot?: IEntitySnapshot;\n}\n\n/**\n * The `IEntityUpdateQueue` interface 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  /**\n   * The number of `EntityUpdate` instances currently in the queue.\n   */\n  readonly size: number;\n\n  /**\n   * Adds an `EntityUpdate` instance to the end of the queue.\n   * @param change - The `EntityUpdate` instance to be added.\n   */\n  enqueue(change: IEntityUpdate): void;\n\n  /**\n   * Removes and returns the `EntityUpdate` instance at the front of the queue.\n   * @returns The `EntityUpdate` instance at the front of the queue.\n   */\n  dequeue(): IEntityUpdate;\n\n  /**\n   * Returns the `EntityUpdate` instance at the front of the queue without removing it.\n   * @returns The `EntityUpdate` instance at the front of the queue.\n   */\n  peek(): IEntityUpdate;\n\n  /**\n   * Removes all `EntityUpdate` instances from the queue.\n   */\n  clear(): void;\n}\n"],"mappings":";;;;;AAOA,IAAY,gEAAL;AACL;AACA;;AACD"}

package/dist/entities/index.d.cts

@@ -1,34 +1,4 @@
-import { I as IEntityProxy } from '../index-CnlpX7ys.cjs';
-export { d as EntityProxy, E as EntityTypeUid, a as EntityUid, c as IEntity, b as IEntityModel, e as IEntityProxiesManager } from '../index-CnlpX7ys.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-DJ1xbvaN.cjs';
-import '../types-cZ-1lGPD.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 {
-    /**
-     * Schedules an entity for updates at a specified interval.
-     *
-     * @param entityProxy - The entity to schedule for updates.
-     * @param intervalMs - The interval at which to schedule updates, in milliseconds. If not provided, the default interval will be used.
-     */
-    schedule(entityProxy: IEntityProxy, intervalMs?: number): void;
-    /**
-     * Removes an entity from the scheduler.
-     *
-     * @param entityProxy - The entity to remove from the scheduler.
-     */
-    remove(entityProxy: IEntityProxy): void;
-    /**
-     * Checks if an entity is currently scheduled for updates.
-     *
-     * @param entityProxy - The entity to check.
-     * @returns `true` if the entity is scheduled, `false` otherwise.
-     */
-    has(entityProxy: IEntityProxy): boolean;
-}
-
-export { IEntityProxy, type IEntityScheduler };
+import { EntityProxy, EntityTypeUid, EntityUid, IEntity, IEntityModel, IEntityModelWithFeatures, IEntityModelWithRequiredProxies, IEntityProxy, IEntityProxyRepository, RequiredProxies, TypedEntityProxy } from "../identity-component-BDWEtAXA.cjs";
+import "../types-DvzdpbLu.cjs";
+import { EntityEventSubscriptionFilter, EntityEventUid, EntityUpdateType, IEntityEvent, IEntityEventsDispatcher, IEntityEventsManager, IEntityRepository, IEntityScheduler, IEntitySnapshot, IEntitySnapshotProvider, IEntityUpdate, IEntityUpdateQueue, IEventData } from "../index-DLm-DKAk.cjs";
+export { EntityEventSubscriptionFilter, EntityEventUid, EntityProxy, EntityTypeUid, EntityUid, EntityUpdateType, IEntity, IEntityEvent, IEntityEventsDispatcher, IEntityEventsManager, IEntityModel, IEntityModelWithFeatures, IEntityModelWithRequiredProxies, IEntityProxy, IEntityProxyRepository, IEntityRepository, IEntityScheduler, IEntitySnapshot, IEntitySnapshotProvider, IEntityUpdate, IEntityUpdateQueue, IEventData, RequiredProxies, TypedEntityProxy };

package/dist/entities/index.d.ts

@@ -1,34 +1,4 @@
-import { I as IEntityProxy } from '../index-B1KXekZD.js';
-export { d as EntityProxy, E as EntityTypeUid, a as EntityUid, c as IEntity, b as IEntityModel, e as IEntityProxiesManager } from '../index-B1KXekZD.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-BlSpo-x2.js';
-import '../types-cZ-1lGPD.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 {
-    /**
-     * Schedules an entity for updates at a specified interval.
-     *
-     * @param entityProxy - The entity to schedule for updates.
-     * @param intervalMs - The interval at which to schedule updates, in milliseconds. If not provided, the default interval will be used.
-     */
-    schedule(entityProxy: IEntityProxy, intervalMs?: number): void;
-    /**
-     * Removes an entity from the scheduler.
-     *
-     * @param entityProxy - The entity to remove from the scheduler.
-     */
-    remove(entityProxy: IEntityProxy): void;
-    /**
-     * Checks if an entity is currently scheduled for updates.
-     *
-     * @param entityProxy - The entity to check.
-     * @returns `true` if the entity is scheduled, `false` otherwise.
-     */
-    has(entityProxy: IEntityProxy): boolean;
-}
-
-export { IEntityProxy, type IEntityScheduler };
+import { EntityProxy, EntityTypeUid, EntityUid, IEntity, IEntityModel, IEntityModelWithFeatures, IEntityModelWithRequiredProxies, IEntityProxy, IEntityProxyRepository, RequiredProxies, TypedEntityProxy } from "../identity-component-CR1ULadR.js";
+import "../types-yh4pOGEm.js";
+import { EntityEventSubscriptionFilter, EntityEventUid, EntityUpdateType, IEntityEvent, IEntityEventsDispatcher, IEntityEventsManager, IEntityRepository, IEntityScheduler, IEntitySnapshot, IEntitySnapshotProvider, IEntityUpdate, IEntityUpdateQueue, IEventData } from "../index-C3UGZqUG.js";
+export { EntityEventSubscriptionFilter, EntityEventUid, EntityProxy, EntityTypeUid, EntityUid, EntityUpdateType, IEntity, IEntityEvent, IEntityEventsDispatcher, IEntityEventsManager, IEntityModel, IEntityModelWithFeatures, IEntityModelWithRequiredProxies, IEntityProxy, IEntityProxyRepository, IEntityRepository, IEntityScheduler, IEntitySnapshot, IEntitySnapshotProvider, IEntityUpdate, IEntityUpdateQueue, IEventData, RequiredProxies, TypedEntityProxy };

package/dist/entities/index.js

@@ -1,10 +1,13 @@
-// src/entities/entity-queue.ts
-var EntityUpdateType = /* @__PURE__ */ ((EntityUpdateType2) => {
-  EntityUpdateType2["update"] = "update";
-  EntityUpdateType2["remove"] = "remove";
-  return EntityUpdateType2;
-})(EntityUpdateType || {});
-export {
-  EntityUpdateType
-};
+//#region src/entities/entity-queue.ts
+/**
+* The `EntityUpdateType` enum specifies whether the current Entity should be `updated` or `removed`.
+*/
+let EntityUpdateType = /* @__PURE__ */ function(EntityUpdateType$1) {
+	EntityUpdateType$1["update"] = "update";
+	EntityUpdateType$1["remove"] = "remove";
+	return EntityUpdateType$1;
+}({});
+
+//#endregion
+export { EntityUpdateType };
 //# sourceMappingURL=index.js.map

package/dist/entities/index.js.map

@@ -1 +1 @@
-{"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` enum specifies whether the current Entity should be `updated` or `removed`.\n */\nexport enum EntityUpdateType {\n  update = 'update',\n  remove = 'remove'\n}\n\n/**\n * The `IEntityUpdate` interface represents an Entity update that should be applied over an existing Entity.\n */\nexport interface IEntityUpdate {\n  /**\n   * The type of the update, which can be either `update` or `remove`.\n   */\n  type: EntityUpdateType;\n\n  /**\n   * The proxy of the Entity that needs to be updated.\n   */\n  entity: IEntityProxy;\n\n  /**\n   * Optional. The model of the Entity that needs to be updated.\n   */\n  model?: IEntityModel;\n\n  /**\n   * Optional. The snapshot of the Entity that needs to be updated.\n   */\n  snapshot?: IEntitySnapshot;\n}\n\n/**\n * The `IEntityUpdateQueue` interface 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  /**\n   * The number of `EntityUpdate` instances currently in the queue.\n   */\n  readonly size: number;\n\n  /**\n   * Adds an `EntityUpdate` instance to the end of the queue.\n   * @param change - The `EntityUpdate` instance to be added.\n   */\n  enqueue(change: IEntityUpdate): void;\n\n  /**\n   * Removes and returns the `EntityUpdate` instance at the front of the queue.\n   * @returns The `EntityUpdate` instance at the front of the queue.\n   */\n  dequeue(): IEntityUpdate;\n\n  /**\n   * Returns the `EntityUpdate` instance at the front of the queue without removing it.\n   * @returns The `EntityUpdate` instance at the front of the queue.\n   */\n  peek(): IEntityUpdate;\n\n  /**\n   * Removes all `EntityUpdate` instances from the queue.\n   */\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"]}
+{"version":3,"file":"index.js","names":[],"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` enum specifies whether the current Entity should be `updated` or `removed`.\n */\nexport enum EntityUpdateType {\n  update = 'update',\n  remove = 'remove'\n}\n\n/**\n * The `IEntityUpdate` interface represents an Entity update that should be applied over an existing Entity.\n */\nexport interface IEntityUpdate {\n  /**\n   * The type of the update, which can be either `update` or `remove`.\n   */\n  type: EntityUpdateType;\n\n  /**\n   * The proxy of the Entity that needs to be updated.\n   */\n  entity: IEntityProxy;\n\n  /**\n   * Optional. The model of the Entity that needs to be updated.\n   */\n  model?: IEntityModel;\n\n  /**\n   * Optional. The snapshot of the Entity that needs to be updated.\n   */\n  snapshot?: IEntitySnapshot;\n}\n\n/**\n * The `IEntityUpdateQueue` interface 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  /**\n   * The number of `EntityUpdate` instances currently in the queue.\n   */\n  readonly size: number;\n\n  /**\n   * Adds an `EntityUpdate` instance to the end of the queue.\n   * @param change - The `EntityUpdate` instance to be added.\n   */\n  enqueue(change: IEntityUpdate): void;\n\n  /**\n   * Removes and returns the `EntityUpdate` instance at the front of the queue.\n   * @returns The `EntityUpdate` instance at the front of the queue.\n   */\n  dequeue(): IEntityUpdate;\n\n  /**\n   * Returns the `EntityUpdate` instance at the front of the queue without removing it.\n   * @returns The `EntityUpdate` instance at the front of the queue.\n   */\n  peek(): IEntityUpdate;\n\n  /**\n   * Removes all `EntityUpdate` instances from the queue.\n   */\n  clear(): void;\n}\n"],"mappings":";;;;AAOA,IAAY,gEAAL;AACL;AACA;;AACD"}

package/dist/factories/index.cjs

@@ -1,18 +0,0 @@
-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.d.cts

@@ -1,57 +1,57 @@
-import { c as IEntity } from '../index-CnlpX7ys.cjs';
-import { I as ISystemsRuntimeContext, a as ISystemContext } from '../systems-runtime-context-DhtHMczN.cjs';
-import { I as IPipelineContext, M as MiddlewareResult, a as IPipeline } from '../pipeline-DunwPUPZ.cjs';
-import '../types-cZ-1lGPD.cjs';
-import '../entity-repository-DJ1xbvaN.cjs';
-import '../utils/index.cjs';
-import '../performance-timer-BVyl0SRs.cjs';
+import { IEntity } from "../identity-component-BDWEtAXA.cjs";
+import "../types-DvzdpbLu.cjs";
+import "../index-DLm-DKAk.cjs";
+import { IPipeline, IPipelineContext } from "../index-D81Fo9XN.cjs";
+import "../index-ChV4Q5j6.cjs";
+import { ISystemContext, ISystemsRuntimeContext } from "../index-CKh4A7mH.cjs";
 
+//#region src/factories/context-factory.d.ts
 /**
  * The IContextFactory interface is used to create abstraction layers for quickly creating Pipeline Contexts.
  * It helps to avoid manually resolving all dependencies when creating these contexts.
  */
 interface IContextFactory {
-    /**
-     * Creates a new instance of ISystemsRuntimeContext.
-     *
-     * @template TEntity - The type of entity to be used in the runtime context. It must extend IEntity.
-     * @returns A new instance of ISystemsRuntimeContext with the specified entity type.
-     */
-    createRuntimeContext<TEntity extends IEntity>(): ISystemsRuntimeContext<TEntity>;
+  /**
+   * Creates a new instance of ISystemsRuntimeContext.
+   *
+   * @template TEntity - The type of entity to be used in the runtime context. It must extend IEntity.
+   * @returns A new instance of ISystemsRuntimeContext with the specified entity type.
+   */
+  createRuntimeContext<TEntity extends IEntity>(): ISystemsRuntimeContext<TEntity>;
 }
-
+//#endregion
+//#region src/factories/pipeline-factory.d.ts
 /**
  * The PipelineFactory interface provides methods to create different types of pipelines.
  * It helps to quickly create IPipeline objects without manually resolving their dependencies.
  */
 interface IPipelineFactory {
-    /**
-     * Creates a new pipeline with the specified context and result type.
-     *
-     * @template TContext - The type of the pipeline context. It must extend IPipelineContext.
-     * @template TResult - The type of the result returned by the pipeline. Default is MiddlewareResult.
-     * @param name - Optional name for the pipeline. If not provided, a default name will be assigned.
-     * @returns A new instance of IPipeline with the specified context and result type.
-     */
-    createPipeline<TContext extends IPipelineContext, TResult = MiddlewareResult>(name?: string): IPipeline<TContext, TResult>;
-    /**
-     * Creates a new pipeline specifically for systems with the specified entity type and result type.
-     *
-     * @template TEntity - The type of the entity. It must extend IEntity.
-     * @template TResult - The type of the result returned by the pipeline. Default is MiddlewareResult.
-     * @param name - Optional name for the pipeline. If not provided, a default name will be assigned.
-     * @returns A new instance of IPipeline with the specified system context and result type.
-     */
-    createSystemsPipeline<TEntity extends IEntity, TResult = MiddlewareResult>(name?: string): IPipeline<ISystemContext<TEntity>, TResult>;
-    /**
-     * Creates a new pipeline specifically for systems runtime with the specified entity type and result type.
-     *
-     * @template TEntity - The type of the entity. It must extend IEntity.
-     * @template TResult - The type of the result returned by the pipeline. Default is MiddlewareResult.
-     * @param name - Optional name for the pipeline. If not provided, a default name will be assigned.
-     * @returns A new instance of IPipeline with the specified systems runtime context and result type.
-     */
-    createRuntimePipeline<TEntity extends IEntity, TResult = MiddlewareResult>(name?: string): IPipeline<ISystemsRuntimeContext<TEntity>, TResult>;
+  /**
+   * Creates a new pipeline with the specified context and result type.
+   *
+   * @template TContext - The type of the pipeline context. It must extend IPipelineContext.
+   * @param name - Optional name for the pipeline. If not provided, a default name will be assigned.
+   * @returns A new instance of IPipeline with the specified context and result type.
+   */
+  createPipeline<TContext extends IPipelineContext>(name?: string): IPipeline<TContext>;
+  /**
+   * Creates a new pipeline specifically for systems with the specified entity type and result type.
+   *
+   * @template TEntity - The type of the entity. It must extend IEntity.
+   * @param name - Optional name for the pipeline. If not provided, a default name will be assigned.
+   * @returns A new instance of IPipeline with the specified system context and result type.
+   */
+  createSystemsPipeline<TEntity extends IEntity>(name?: string): IPipeline<ISystemContext<TEntity>>;
+  /**
+   * Creates a new pipeline specifically for systems runtime with the specified entity type and result type.
+   *
+   * @template TEntity - The type of the entity. It must extend IEntity.
+   * @template TResult - The type of the result returned by the pipeline. Default is MiddlewareResult.
+   * @param name - Optional name for the pipeline. If not provided, a default name will be assigned.
+   * @returns A new instance of IPipeline with the specified systems runtime context and result type.
+   */
+  createRuntimePipeline<TEntity extends IEntity>(name?: string): IPipeline<ISystemsRuntimeContext<TEntity>>;
 }
-
-export type { IContextFactory, IPipelineFactory };
+//#endregion
+export { IContextFactory, IPipelineFactory };
+//# sourceMappingURL=index.d.cts.map