@awesome-ecs/abstract 0.22.0 → 0.23.0

package/dist/types-DLOd2zXO.d.cts

@@ -0,0 +1,70 @@
+//#region src/utils/types.d.ts
+/**
+ * Maps all properties of a type to boolean flags.
+ * Useful for feature flags, capability indicators, or boolean option sets.
+ *
+ * @template T - The type whose properties are mapped to booleans.
+ * @example type Features = BooleanProps<{health: any; armor: any}>; // => {health: boolean, armor: boolean}
+ */
+type BooleanProps<T> = { [Property in keyof T]: boolean };
+/**
+ * Removes readonly modifiers from all properties, making them mutable.
+ * One level of immutability removal (see MutableDeep for recursive removal).
+ *
+ * @template T - The type to make mutable.
+ * @example type Mut = Mutable<{readonly x: number}>; // => {x: number}
+ */
+type Mutable<T> = { -readonly [K in keyof T]: T[K] };
+/**
+ * Recursively removes readonly modifiers from all properties at all nesting levels.
+ * Makes entire object graph mutable.
+ *
+ * @template T - The type to make mutable recursively.
+ */
+type MutableDeep<T> = { -readonly [K in keyof T]: Mutable<T[K]> };
+type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
+/**
+ * Makes a type fully immutable at the top level only.
+ * Primitives and functions remain unchanged.
+ * Collections (Array, Map, Set) become readonly.
+ * Objects have their properties made readonly.
+ *
+ * @template T - The type to make immutable.
+ * @example type Imm = Immutable<{x: number}>; // => {readonly x: number}
+ */
+type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
+/**
+ * Readonly array variant for use in Immutable type transformation.
+ *
+ * @template T - Element type of the array.
+ */
+type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
+/**
+ * Readonly map variant for use in Immutable type transformation.
+ *
+ * @template K - Key type of the map.
+ * @template V - Value type of the map.
+ */
+type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+/**
+ * Readonly set variant for use in Immutable type transformation.
+ *
+ * @template T - Element type of the set.
+ */
+type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+/**
+ * Makes all object properties readonly (one level only).
+ *
+ * @template T - The type to make immutable.
+ */
+type ImmutableObject<T> = { readonly [K in keyof T]: T[K] };
+/**
+ * Recursively makes all properties readonly at all nesting levels.
+ * Provides complete immutability guarantee for the entire object graph.
+ *
+ * @template T - The type to make deeply immutable.
+ */
+type ImmutableObjectDeep<T> = { readonly [K in keyof T]: Immutable<T[K]> };
+//#endregion
+export { ImmutableObject as a, Mutable as c, ImmutableMap as i, MutableDeep as l, Immutable as n, ImmutableObjectDeep as o, ImmutableArray as r, ImmutableSet as s, BooleanProps as t };
+//# sourceMappingURL=types-DLOd2zXO.d.cts.map

package/dist/utils/index.cjs

@@ -1,26 +1,26 @@
 
 //#region src/utils/logger.ts
 /**
-* An enumeration of log levels.
+* Logging severity levels in increasing order.
 */
-let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
 	/**
-	* Trace-level logging.
+	* Most detailed, diagnostic-level logging.
 	*/
-	LogLevel$1[LogLevel$1["trace"] = 0] = "trace";
+	LogLevel[LogLevel["trace"] = 0] = "trace";
 	/**
-	* Debug-level logging.
+	* Development and debugging information.
 	*/
-	LogLevel$1[LogLevel$1["debug"] = 1] = "debug";
+	LogLevel[LogLevel["debug"] = 1] = "debug";
 	/**
-	* Warning-level logging.
+	* Warning-level conditions.
 	*/
-	LogLevel$1[LogLevel$1["warn"] = 2] = "warn";
+	LogLevel[LogLevel["warn"] = 2] = "warn";
 	/**
-	* Error-level logging.
+	* Error-level conditions.
 	*/
-	LogLevel$1[LogLevel$1["error"] = 3] = "error";
-	return LogLevel$1;
+	LogLevel[LogLevel["error"] = 3] = "error";
+	return LogLevel;
 }({});
 
 //#endregion

package/dist/utils/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/utils/logger.ts"],"sourcesContent":["/**\n * An ILogger instance allows printing messages to console or other targets.\n */\nexport interface ILogger {\n  /**\n   * Logs a message with a specified level.\n   * @param level The level of the message.\n   * @param message The message to be logged.\n   * @param ...args Additional arguments to be included in the message.\n   */\n  log(level: LogLevel, message: any, ...args: any[]): void;\n\n  /**\n   * Logs a trace-level message.\n   * @param message The message to be logged.\n   * @param ...args Additional arguments to be included in the message.\n   */\n  trace(message: any, ...args: any[]): void;\n\n  /**\n   * Logs a debug-level message.\n   * @param message The message to be logged.\n   * @param ...args Additional arguments to be included in the message.\n   */\n  debug(message: any, ...args: any[]): void;\n\n  /**\n   * Logs a warning-level message.\n   * @param message The message to be logged.\n   * @param ...args Additional arguments to be included in the message.\n   */\n  warn(message: any, ...args: any[]): void;\n\n  /**\n   * Logs an error-level message.\n   * @param message The message to be logged.\n   * @param ...args Additional arguments to be included in the message.\n   */\n  error(message: any, ...args: any[]): void;\n}\n\n/**\n * An enumeration of log levels.\n */\nexport enum LogLevel {\n  /**\n   * Trace-level logging.\n   */\n  trace,\n\n  /**\n   * Debug-level logging.\n   */\n  debug,\n\n  /**\n   * Warning-level logging.\n   */\n  warn,\n\n  /**\n   * Error-level logging.\n   */\n  error\n}\n\n/**\n * Options for configuring an ILogger instance.\n */\nexport interface ILoggerOptions {\n  /**\n   * A map of log levels to their corresponding enabled status.\n   */\n  enabled: Map<LogLevel, boolean>;\n}\n"],"mappings":";;;;;AA4CA,IAAY,gDAAL;;;;AAIL;;;;AAKA;;;;AAKA;;;;AAKA;;AACD"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/utils/logger.ts"],"sourcesContent":["/**\r\n * Logger interface for debug and diagnostic output.\r\n * Supports multiple log levels for controlling verbosity.\r\n * Implementations can target different outputs (console, file, remote, etc.).\r\n */\r\nexport interface ILogger {\r\n  /**\r\n   * Logs a message with a specified severity level.\r\n   * @param level - The severity level of the message.\r\n   * @param message - The primary message content.\r\n   * @param args - Additional arguments to include in the log output.\r\n   */\r\n  log(level: LogLevel, message: any, ...args: any[]): void;\r\n\r\n  /**\r\n   * Logs detailed diagnostic information.\r\n   * Typically the lowest level, most verbose output.\r\n   * @param message - The message to log.\r\n   * @param args - Additional data.\r\n   */\r\n  trace(message: any, ...args: any[]): void;\r\n\r\n  /**\r\n   * Logs debug-level information.\r\n   * Useful during development and troubleshooting.\r\n   * @param message - The message to log.\r\n   * @param args - Additional data.\r\n   */\r\n  debug(message: any, ...args: any[]): void;\r\n\r\n  /**\r\n   * Logs warning-level messages.\r\n   * Indicates potentially problematic conditions.\r\n   * @param message - The message to log.\r\n   * @param args - Additional data.\r\n   */\r\n  warn(message: any, ...args: any[]): void;\r\n\r\n  /**\r\n   * Logs error-level messages.\r\n   * Indicates error conditions that may require attention.\r\n   * @param message - The message to log.\r\n   * @param args - Additional data.\r\n   */\r\n  error(message: any, ...args: any[]): void;\r\n}\r\n\r\n/**\r\n * Logging severity levels in increasing order.\r\n */\r\nexport enum LogLevel {\r\n  /**\r\n   * Most detailed, diagnostic-level logging.\r\n   */\r\n  trace,\r\n\r\n  /**\r\n   * Development and debugging information.\r\n   */\r\n  debug,\r\n\r\n  /**\r\n   * Warning-level conditions.\r\n   */\r\n  warn,\r\n\r\n  /**\r\n   * Error-level conditions.\r\n   */\r\n  error\r\n}\r\n\r\n/**\r\n * Configuration options for logger instances.\r\n */\r\nexport interface ILoggerOptions {\r\n  /**\r\n   * Enables/disables each log level.\r\n   * If a level is disabled, log calls at that level are ignored.\r\n   */\r\n  enabled: Map<LogLevel, boolean>;\r\n}\r\n"],"mappings":";;;;;AAkDA,IAAY,8CAAL;;;;AAIL;;;;AAKA;;;;AAKA;;;;AAKA"}

package/dist/utils/index.d.cts

@@ -1,3 +1,3 @@
-import { BooleanProps, Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableObjectDeep, ImmutableSet, Mutable, MutableDeep } from "../types-DvzdpbLu.cjs";
-import { IJsonSerializer, ILogger, ILoggerOptions, IPerformanceTimer, LogLevel, PerformanceTimeEntry, PerformanceTimerUid } from "../index-ChV4Q5j6.cjs";
+import { a as ImmutableObject, c as Mutable, i as ImmutableMap, l as MutableDeep, n as Immutable, o as ImmutableObjectDeep, r as ImmutableArray, s as ImmutableSet, t as BooleanProps } from "../types-DLOd2zXO.cjs";
+import { a as ILoggerOptions, i as ILogger, n as PerformanceTimeEntry, o as LogLevel, r as PerformanceTimerUid, s as IJsonSerializer, t as IPerformanceTimer } from "../index-eECJUE_O.cjs";
 export { BooleanProps, IJsonSerializer, ILogger, ILoggerOptions, IPerformanceTimer, Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableObjectDeep, ImmutableSet, LogLevel, Mutable, MutableDeep, PerformanceTimeEntry, PerformanceTimerUid };

package/dist/utils/index.d.mts

@@ -0,0 +1,3 @@
+import { a as ImmutableObject, c as Mutable, i as ImmutableMap, l as MutableDeep, n as Immutable, o as ImmutableObjectDeep, r as ImmutableArray, s as ImmutableSet, t as BooleanProps } from "../types-CnDtpKsY.mjs";
+import { a as ILoggerOptions, i as ILogger, n as PerformanceTimeEntry, o as LogLevel, r as PerformanceTimerUid, s as IJsonSerializer, t as IPerformanceTimer } from "../index-BWmhFdFg.mjs";
+export { BooleanProps, IJsonSerializer, ILogger, ILoggerOptions, IPerformanceTimer, Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableObjectDeep, ImmutableSet, LogLevel, Mutable, MutableDeep, PerformanceTimeEntry, PerformanceTimerUid };

package/dist/utils/index.mjs

@@ -0,0 +1,27 @@
+//#region src/utils/logger.ts
+/**
+* Logging severity levels in increasing order.
+*/
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	/**
+	* Most detailed, diagnostic-level logging.
+	*/
+	LogLevel[LogLevel["trace"] = 0] = "trace";
+	/**
+	* Development and debugging information.
+	*/
+	LogLevel[LogLevel["debug"] = 1] = "debug";
+	/**
+	* Warning-level conditions.
+	*/
+	LogLevel[LogLevel["warn"] = 2] = "warn";
+	/**
+	* Error-level conditions.
+	*/
+	LogLevel[LogLevel["error"] = 3] = "error";
+	return LogLevel;
+}({});
+
+//#endregion
+export { LogLevel };
+//# sourceMappingURL=index.mjs.map

package/dist/utils/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/utils/logger.ts"],"sourcesContent":["/**\r\n * Logger interface for debug and diagnostic output.\r\n * Supports multiple log levels for controlling verbosity.\r\n * Implementations can target different outputs (console, file, remote, etc.).\r\n */\r\nexport interface ILogger {\r\n  /**\r\n   * Logs a message with a specified severity level.\r\n   * @param level - The severity level of the message.\r\n   * @param message - The primary message content.\r\n   * @param args - Additional arguments to include in the log output.\r\n   */\r\n  log(level: LogLevel, message: any, ...args: any[]): void;\r\n\r\n  /**\r\n   * Logs detailed diagnostic information.\r\n   * Typically the lowest level, most verbose output.\r\n   * @param message - The message to log.\r\n   * @param args - Additional data.\r\n   */\r\n  trace(message: any, ...args: any[]): void;\r\n\r\n  /**\r\n   * Logs debug-level information.\r\n   * Useful during development and troubleshooting.\r\n   * @param message - The message to log.\r\n   * @param args - Additional data.\r\n   */\r\n  debug(message: any, ...args: any[]): void;\r\n\r\n  /**\r\n   * Logs warning-level messages.\r\n   * Indicates potentially problematic conditions.\r\n   * @param message - The message to log.\r\n   * @param args - Additional data.\r\n   */\r\n  warn(message: any, ...args: any[]): void;\r\n\r\n  /**\r\n   * Logs error-level messages.\r\n   * Indicates error conditions that may require attention.\r\n   * @param message - The message to log.\r\n   * @param args - Additional data.\r\n   */\r\n  error(message: any, ...args: any[]): void;\r\n}\r\n\r\n/**\r\n * Logging severity levels in increasing order.\r\n */\r\nexport enum LogLevel {\r\n  /**\r\n   * Most detailed, diagnostic-level logging.\r\n   */\r\n  trace,\r\n\r\n  /**\r\n   * Development and debugging information.\r\n   */\r\n  debug,\r\n\r\n  /**\r\n   * Warning-level conditions.\r\n   */\r\n  warn,\r\n\r\n  /**\r\n   * Error-level conditions.\r\n   */\r\n  error\r\n}\r\n\r\n/**\r\n * Configuration options for logger instances.\r\n */\r\nexport interface ILoggerOptions {\r\n  /**\r\n   * Enables/disables each log level.\r\n   * If a level is disabled, log calls at that level are ignored.\r\n   */\r\n  enabled: Map<LogLevel, boolean>;\r\n}\r\n"],"mappings":";;;;AAkDA,IAAY,8CAAL;;;;AAIL;;;;AAKA;;;;AAKA;;;;AAKA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awesome-ecs/abstract",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "A comprehensive Entity-Component-System (ECS) Architecture implementation. Abstract components.",
   "type": "module",
   "scripts": {
@@ -14,8 +14,8 @@
   "exports": {
     "./components": {
       "import": {
-        "types": "./dist/components/index.d.ts",
-        "default": "./dist/components/index.js"
+        "types": "./dist/components/index.d.mts",
+        "default": "./dist/components/index.mjs"
       },
       "require": {
         "types": "./dist/components/index.d.cts",
@@ -24,8 +24,8 @@
     },
     "./entities": {
       "import": {
-        "types": "./dist/entities/index.d.ts",
-        "default": "./dist/entities/index.js"
+        "types": "./dist/entities/index.d.mts",
+        "default": "./dist/entities/index.mjs"
       },
       "require": {
         "types": "./dist/entities/index.d.cts",
@@ -34,8 +34,8 @@
     },
     "./factories": {
       "import": {
-        "types": "./dist/factories/index.d.ts",
-        "default": "./dist/factories/index.js"
+        "types": "./dist/factories/index.d.mts",
+        "default": "./dist/factories/index.mjs"
       },
       "require": {
         "types": "./dist/factories/index.d.cts",
@@ -44,8 +44,8 @@
     },
     "./pipelines": {
       "import": {
-        "types": "./dist/pipelines/index.d.ts",
-        "default": "./dist/pipelines/index.js"
+        "types": "./dist/pipelines/index.d.mts",
+        "default": "./dist/pipelines/index.mjs"
       },
       "require": {
         "types": "./dist/pipelines/index.d.cts",
@@ -54,8 +54,8 @@
     },
     "./systems": {
       "import": {
-        "types": "./dist/systems/index.d.ts",
-        "default": "./dist/systems/index.js"
+        "types": "./dist/systems/index.d.mts",
+        "default": "./dist/systems/index.mjs"
       },
       "require": {
         "types": "./dist/systems/index.d.cts",
@@ -64,8 +64,8 @@
     },
     "./utils": {
       "import": {
-        "types": "./dist/utils/index.d.ts",
-        "default": "./dist/utils/index.js"
+        "types": "./dist/utils/index.d.mts",
+        "default": "./dist/utils/index.mjs"
       },
       "require": {
         "types": "./dist/utils/index.d.cts",
@@ -97,5 +97,5 @@
     "url": "https://github.com/privatebytes/awesome-ecs/issues"
   },
   "homepage": "https://github.com/privatebytes/awesome-ecs#readme",
-  "gitHead": "9e875e10e5191853fb48c20b3ebb3eafc8c002b1"
+  "gitHead": "8409c84b5ac82181b01ad384d5732e84f6f5e13a"
 }

package/dist/components/index.d.ts

@@ -1,3 +0,0 @@
-import { BasicComponentType, ComponentTypeUid, IComponent, IdentityComponent } from "../identity-component-CR1ULadR.js";
-import "../types-yh4pOGEm.js";
-export { BasicComponentType, ComponentTypeUid, IComponent, IdentityComponent };

package/dist/components/index.js.map

@@ -1 +0,0 @@
-{"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.d.ts

@@ -1,4 +0,0 @@
-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,13 +0,0 @@
-//#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 +0,0 @@
-{"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.d.ts

@@ -1,57 +0,0 @@
-import { IEntity } from "../identity-component-CR1ULadR.js";
-import "../types-yh4pOGEm.js";
-import "../index-C3UGZqUG.js";
-import { IPipeline, IPipelineContext } from "../index-Cm-YSPhK.js";
-import "../index-oenqxDCa.js";
-import { ISystemContext, ISystemsRuntimeContext } from "../index-CH8ucsKZ.js";
-
-//#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>;
-}
-//#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.
-   * @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>>;
-}
-//#endregion
-export { IContextFactory, IPipelineFactory };
-//# sourceMappingURL=index.d.ts.map

package/dist/identity-component-BDWEtAXA.d.cts

@@ -1,238 +0,0 @@
-import { BooleanProps, Immutable } from "./types-DvzdpbLu.cjs";
-
-//#region src/components/component.d.ts
-type ComponentTypeUid = string | number;
-/**
- * The `IComponent` interface 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.
- */
-interface IComponent {
-  /**
-   * The `ComponentTypeUid` is a unique identifier for each Component type.
-   * @type {ComponentTypeUid}
-   */
-  readonly componentType: ComponentTypeUid;
-  /**
-   * Specifies whether the Component state should be serialized as part of an `IEntitySnapshot`.
-   * This is useful if the state needs to be replicated or updated through remote updates (e.g., coming from the server or peers).
-   * @type {boolean}
-   */
-  readonly isSerializable: boolean;
-  /**
-   * @optional
-   * Specifies the current version of the component.
-   * This is useful for keeping backwards-compatibility when the stored state might be of a different version.
-   * @type {number}
-   */
-  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.
-   * @returns {string | object} The serialized form of the Component.
-   */
-  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 {this} targetState The target state to load from.
-   */
-  load?(targetState: this): void;
-}
-//#endregion
-//#region src/entities/entity-proxies.d.ts
-/**
- * The `IEntityProxy` represents a pointer to another `Entity`.
- */
-interface IEntityProxy {
-  /**
-   * The type of the entity that the proxy points to.
-   */
-  readonly entityType: EntityTypeUid;
-  /**
-   * The unique identifier of the entity that the proxy points to.
-   */
-  readonly entityUid: EntityUid;
-}
-/**
- * A utility extension of `IEntityProxy`.
- * Useful for providing strong `Type` information when using the IEntityProxy.
- *
- * @template TEntity - The type of the entity that the proxy points to.
- */
-interface EntityProxy<TEntity extends IEntity> extends IEntityProxy {}
-/**
- * A helper type to create a typed entity proxy.
- */
-type TypedEntityProxy<T extends EntityTypeUid> = {
-  entityType: T;
-  entityUid: EntityUid;
-};
-/**
- * A mapped type that transforms an array of EntityType into an array of TypedEntityProxy.
- */
-type RequiredProxies<TProxyTypes extends readonly EntityTypeUid[]> = [...{ [I in keyof TProxyTypes]: TypedEntityProxy<TProxyTypes[I]> }, ...IEntityProxy[]];
-/**
- * A repository for managing entity-to-entity relationships (proxies).
- * This centralized repository is the single source of truth for all proxy data.
- */
-interface IEntityProxyRepository {
-  /**
-   * Registers a bi-directional proxy relationship between a source and a target.
-   * @param source - The proxy of the source entity.
-   * @param target - The proxy of the target entity.
-   * @param cleanup - If true, any existing proxies of the same type on the source and target will be removed before registering the new one.
-   */
-  register(source: IEntityProxy, target: IEntityProxy, cleanup?: boolean): void;
-  /**
-   * Registers multiple bi-directional proxy relationships for a source entity.
-   * @param source - The proxy of the source entity.
-   * @param targets - The proxies of the target entities.
-   * @param cleanup - If true, any existing proxies of the same types as the new targets will be removed from the source before registering.
-   */
-  registerMany(source: IEntityProxy, targets: readonly IEntityProxy[], cleanup?: boolean): void;
-  /**
-   * Removes a bi-directional proxy relationship between a source and a target.
-   * @param source - The proxy of the source entity.
-   * @param target - The proxy of the target entity.
-   */
-  remove(source: IEntityProxy, target: IEntityProxy): void;
-  /**
-   * Removes all proxies from a source entity, optionally filtered by the target entity type.
-   * This will also remove the corresponding back-references from the target entities.
-   * @param source - The proxy of the source entity.
-   * @param targetType - The optional entity type of the targets to remove. If not provided, all proxies for the source are removed.
-   */
-  removeAllFor(source: IEntityProxy, targetType?: EntityTypeUid): void;
-  /**
-   * Retrieves a single proxy of a specific type for a source entity.
-   * If multiple proxies of the same type exist, it returns the first one found.
-   * @param source - The proxy of the source entity.
-   * @param targetType - The entity type of the target proxy to retrieve.
-   * @returns The entity proxy, or null if not found.
-   */
-  get(source: IEntityProxy, targetType: EntityTypeUid): IEntityProxy | null;
-  /**
-   * Retrieves all proxies of a specific type for a source entity.
-   * @param source - The proxy of the source entity.
-   * @param targetType - The entity type of the target proxies to retrieve.
-   * @returns A readonly array of entity proxies.
-   */
-  getMany(source: IEntityProxy, targetType: EntityTypeUid): Readonly<IEntityProxy[]>;
-  /**
-   * Retrieves all proxies for a source entity.
-   * @param source - The proxy of the source entity.
-   * @returns A readonly map of entity type UIDs to an array of their proxies.
-   */
-  getAll(source: IEntityProxy): ReadonlyMap<EntityTypeUid, Readonly<IEntityProxy[]>>;
-}
-//#endregion
-//#region src/entities/entity.d.ts
-/**
- * Represents the unique identifier for an entity type.
- * Can be either a string or a number.
- */
-type EntityTypeUid = string | number;
-/**
- * Represents the unique identifier for an entity.
- * Can be either a string or a number.
- */
-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.
- *
- * The Features property can be used to toggle Entity features on and off.
- *
- * @template TFeatures - A type that extends `BooleanProps<TFeatures>` to represent the features of the entity.
- *                      Defaults to `unknown` if not provided.
- */
-interface IEntityModel {
-  /**
-   * The unique identifier of the entity.
-   */
-  readonly uid: EntityUid;
-  /**
-   * Optional proxies of the entity.
-   */
-  readonly proxies?: readonly IEntityProxy[];
-}
-/**
- * Base interface for entity models that require feature flags.
- * @template TFeatures - A type that extends `BooleanProps<TFeatures>` to represent the features of the entity.
- */
-interface IEntityModelWithFeatures<TFeatures extends BooleanProps<TFeatures> = unknown> extends IEntityModel {
-  readonly features: TFeatures;
-}
-/**
- * Base interface for entity models that require specific proxies.
- * @template TProxyTypes An array of EntityType that are required as proxies.
- */
-interface IEntityModelWithRequiredProxies<TProxyTypes extends readonly EntityTypeUid[]> extends Omit<IEntityModel, 'proxies'> {
-  readonly proxies: RequiredProxies<TProxyTypes>;
-}
-/**
- * The `IEntity` interface represents a container of Components and Entity Proxies.
- * It is designed to be immutable and only modifiable through System operations.
- *
- * Implementations of `IEntity` can contain quick-access methods for `Components` or `Proxies`,
- * but should not contain any state-changing logic apart from quick-access functionality.
- */
-interface IEntity {
-  /**
-   * A Map of Components associated with this Entity.
-   * The keys are ComponentTypeUid, and the values are IComponent instances.
-   */
-  readonly components: ReadonlyMap<ComponentTypeUid, IComponent>;
-  /**
-   * The IdentityComponent represents mandatory state any Entity needs to have.
-   * It is a readonly reference to an IdentityComponent instance, which contains the minimal-required information
-   * needed for instantiating the Entity.
-   */
-  readonly identity: Readonly<IdentityComponent<IEntityModel>>;
-  /**
-   * A reference to the own Proxy of this Entity.
-   * It is a readonly reference to an IEntityProxy instance, which points to this Entity.
-   * This is useful for quick access of Proxy data.
-   */
-  readonly myProxy: Readonly<EntityProxy<this>>;
-}
-//#endregion
-//#region src/components/identity-component.d.ts
-/**
- * The `BasicComponentType` enum defines the types of basic components available.
- */
-declare enum BasicComponentType {
-  identity = "identity",
-}
-/**
- * IdentityComponent interface represents the basic information regarding what makes the current Entity unique.
- * It extends the IComponent interface.
- *
- * @template TModel - The type of the model that extends IEntityModel.
- */
-interface IdentityComponent<TModel extends IEntityModel> extends IComponent {
-  /**
-   * The Entity Type that defines what Category type the Entity is part of.
-   * There can be multiple Entities sharing the same EntityType.
-   */
-  readonly entityType: EntityTypeUid;
-  /**
-   * The Model is the basic information needed to create an `IEntity` when it's first initialized.
-   * It provides a first snapshot of information needed for the successful creation of an Entity instance.
-   *
-   * @type {Immutable<TModel>}
-   */
-  readonly model: Immutable<TModel>;
-  /**
-   * Keeps track when the Entity's systems have ran last.
-   * Useful to calculate the `DeltaTime` between runs.
-   *
-   * @type {Date | undefined}
-   */
-  readonly lastUpdated?: Date;
-}
-//#endregion
-export { BasicComponentType, ComponentTypeUid, EntityProxy, EntityTypeUid, EntityUid, IComponent, IEntity, IEntityModel, IEntityModelWithFeatures, IEntityModelWithRequiredProxies, IEntityProxy, IEntityProxyRepository, IdentityComponent, RequiredProxies, TypedEntityProxy };
-//# sourceMappingURL=identity-component-BDWEtAXA.d.cts.map