@awesome-ecs/abstract 0.15.0 → 0.18.0

package/dist/systems/index.d.cts

@@ -0,0 +1,55 @@
+import { I as ISystemsRuntimeContext, a as ISystemContext, S as SystemType } from '../systems-runtime-context-Cq4vxbHX.cjs';
+export { b as ISystemContextEntity, c as ISystemContextEvents, d as ISystemContextProxies, e as ISystemContextRepository, f as ISystemContextScheduler, g as ISystemContextSnapshot } from '../systems-runtime-context-Cq4vxbHX.cjs';
+import { c as IEntity } from '../index-DK2CXVZ8.cjs';
+import { b as IMiddleware, P as PipelineResult } from '../pipeline-BowCAITe.cjs';
+import { f as IEntityUpdate } from '../entity-repository-awW_H993.cjs';
+import '../types-BNwBqRWY.cjs';
+import '../utils/index.cjs';
+import '../performance-timer-XvdCbcAE.cjs';
+
+/**
+ * The ISystemsRuntimeMiddleware represents the building blocks of executing SystemsModule's registered Pipelines.
+ * It receives the current State in the Context, and can decide which SystemPipelines to execute.
+ */
+type ISystemsRuntimeMiddleware<TEntity extends IEntity> = IMiddleware<ISystemsRuntimeContext<TEntity>>;
+
+/**
+ * The SystemMiddleware is the basic System implementation that can be registered as a Middleware in a SystemPipeline.
+ * It provides a SystemPipelineContext to it's exposed methods.
+ */
+type ISystemMiddleware<TEntity extends IEntity> = IMiddleware<ISystemContext<TEntity>>;
+
+/**
+ * The SystemModule is the main way of registering and triggering the SystemMiddlewares registered for an Entity.
+ * It can handle EntityUpdate objects and decides which SystemPipelines to trigger based on the information in the EntityUpdate.
+ */
+interface ISystemsModule<TEntity extends IEntity> {
+    /**
+     * @param type The SystemPipelineType to append the provided SystemMiddlewares to.
+     * @param systems The SystemMiddlewares will be registered in the provided SystemPipelineType in the same order as the provided array.
+     * The SystemMiddlewares will be appended to existing Pipelines to allow easy extension of existing behaviors.
+     */
+    registerSystems(type: SystemType, systems: ISystemMiddleware<TEntity>[]): void;
+    /**
+     * Trigger all registered SystemPipelines, to apply the changes from the provided EntityUpdate to an Entity instance.
+     * @param update The EntityUpdate containing the desired changes to be applied on an Entity instance.
+     */
+    triggerSystems(update: IEntityUpdate): PipelineResult;
+}
+
+/**
+ * The System Runtime allows running a loop of Ticks.
+ *
+ * Each RunTick can process one or more Entity Updates, from the EntityQueue.
+ * We can have multiple implementations of a SystemRuntime, based on the use-case.
+ * A different implementation can be chosen at runtime, based for example on performance.
+ */
+interface ISystemsRuntime {
+    /**
+     * The method should trigger the SystemsModule logic for the provided IEntityUpdate.
+     * If no EntityUpdate is given, the SystemRuntime implementation can choose to dequeue one from the IEntityUpdateQueue.
+     */
+    runTick(update?: IEntityUpdate): PipelineResult;
+}
+
+export { ISystemContext, type ISystemMiddleware, type ISystemsModule, type ISystemsRuntime, ISystemsRuntimeContext, type ISystemsRuntimeMiddleware, SystemType };

package/dist/systems/index.d.ts

@@ -1,13 +1,55 @@
-export * from "./context/system-context-entity";
-export * from "./context/system-context-events";
-export * from "./context/system-context-proxies";
-export * from "./context/system-context-repository";
-export * from "./context/system-context-scheduler";
-export * from "./context/system-context-snapshot";
-export * from "./runtime/systems-runtime-context";
-export * from "./runtime/systems-runtime-middleware";
-export * from "./system-middleware";
-export * from "./system-context";
-export * from "./system-type";
-export * from "./systems-module";
-export * from "./systems-runtime";
+import { I as ISystemsRuntimeContext, a as ISystemContext, S as SystemType } from '../systems-runtime-context-DjppCqs4.js';
+export { b as ISystemContextEntity, c as ISystemContextEvents, d as ISystemContextProxies, e as ISystemContextRepository, f as ISystemContextScheduler, g as ISystemContextSnapshot } from '../systems-runtime-context-DjppCqs4.js';
+import { c as IEntity } from '../index-BPDsRt_F.js';
+import { b as IMiddleware, P as PipelineResult } from '../pipeline-D43CXxWG.js';
+import { f as IEntityUpdate } from '../entity-repository-Bu6rH-m5.js';
+import '../types-BNwBqRWY.js';
+import '../utils/index.js';
+import '../performance-timer-XvdCbcAE.js';
+
+/**
+ * The ISystemsRuntimeMiddleware represents the building blocks of executing SystemsModule's registered Pipelines.
+ * It receives the current State in the Context, and can decide which SystemPipelines to execute.
+ */
+type ISystemsRuntimeMiddleware<TEntity extends IEntity> = IMiddleware<ISystemsRuntimeContext<TEntity>>;
+
+/**
+ * The SystemMiddleware is the basic System implementation that can be registered as a Middleware in a SystemPipeline.
+ * It provides a SystemPipelineContext to it's exposed methods.
+ */
+type ISystemMiddleware<TEntity extends IEntity> = IMiddleware<ISystemContext<TEntity>>;
+
+/**
+ * The SystemModule is the main way of registering and triggering the SystemMiddlewares registered for an Entity.
+ * It can handle EntityUpdate objects and decides which SystemPipelines to trigger based on the information in the EntityUpdate.
+ */
+interface ISystemsModule<TEntity extends IEntity> {
+    /**
+     * @param type The SystemPipelineType to append the provided SystemMiddlewares to.
+     * @param systems The SystemMiddlewares will be registered in the provided SystemPipelineType in the same order as the provided array.
+     * The SystemMiddlewares will be appended to existing Pipelines to allow easy extension of existing behaviors.
+     */
+    registerSystems(type: SystemType, systems: ISystemMiddleware<TEntity>[]): void;
+    /**
+     * Trigger all registered SystemPipelines, to apply the changes from the provided EntityUpdate to an Entity instance.
+     * @param update The EntityUpdate containing the desired changes to be applied on an Entity instance.
+     */
+    triggerSystems(update: IEntityUpdate): PipelineResult;
+}
+
+/**
+ * The System Runtime allows running a loop of Ticks.
+ *
+ * Each RunTick can process one or more Entity Updates, from the EntityQueue.
+ * We can have multiple implementations of a SystemRuntime, based on the use-case.
+ * A different implementation can be chosen at runtime, based for example on performance.
+ */
+interface ISystemsRuntime {
+    /**
+     * The method should trigger the SystemsModule logic for the provided IEntityUpdate.
+     * If no EntityUpdate is given, the SystemRuntime implementation can choose to dequeue one from the IEntityUpdateQueue.
+     */
+    runTick(update?: IEntityUpdate): PipelineResult;
+}
+
+export { ISystemContext, type ISystemMiddleware, type ISystemsModule, type ISystemsRuntime, ISystemsRuntimeContext, type ISystemsRuntimeMiddleware, SystemType };

package/dist/systems/index.js

@@ -1,30 +1,12 @@
-"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/systems/module/system-type.ts
+var SystemType = /* @__PURE__ */ ((SystemType2) => {
+  SystemType2["initialize"] = "initialize";
+  SystemType2["update"] = "update";
+  SystemType2["render"] = "render";
+  SystemType2["sync"] = "sync";
+  return SystemType2;
+})(SystemType || {});
+export {
+  SystemType
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./context/system-context-entity"), exports);
-__exportStar(require("./context/system-context-events"), exports);
-__exportStar(require("./context/system-context-proxies"), exports);
-__exportStar(require("./context/system-context-repository"), exports);
-__exportStar(require("./context/system-context-scheduler"), exports);
-__exportStar(require("./context/system-context-snapshot"), exports);
-__exportStar(require("./runtime/systems-runtime-context"), exports);
-__exportStar(require("./runtime/systems-runtime-middleware"), exports);
-__exportStar(require("./system-middleware"), exports);
-__exportStar(require("./system-context"), exports);
-__exportStar(require("./system-type"), exports);
-__exportStar(require("./systems-module"), exports);
-__exportStar(require("./systems-runtime"), exports);
 //# sourceMappingURL=index.js.map

package/dist/systems/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/systems/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kEAAgD;AAChD,kEAAgD;AAChD,mEAAiD;AACjD,sEAAoD;AACpD,qEAAmD;AACnD,oEAAkD;AAClD,oEAAkD;AAClD,uEAAqD;AACrD,sDAAoC;AACpC,mDAAiC;AACjC,gDAA8B;AAC9B,mDAAiC;AACjC,oDAAkC"}
+{"version":3,"sources":["../../src/systems/module/system-type.ts"],"sourcesContent":["/**\n * The built-in ECS pipeline types. They can be extended to introduce more types, and the System Runtime Pipeline should\n * add Middleware to handle the newly added types.\n */\nexport enum SystemType {\n  initialize = \"initialize\",\n  update = \"update\",\n  render = \"render\",\n  sync = \"sync\",\n}\n"],"mappings":";AAIO,IAAK,aAAL,kBAAKA,gBAAL;AACL,EAAAA,YAAA,gBAAa;AACb,EAAAA,YAAA,YAAS;AACT,EAAAA,YAAA,YAAS;AACT,EAAAA,YAAA,UAAO;AAJG,SAAAA;AAAA,GAAA;","names":["SystemType"]}

package/dist/systems-runtime-context-Cq4vxbHX.d.cts

@@ -0,0 +1,163 @@
+import { c as IEntity, I as IEntityProxy, E as EntityTypeUid, b as IEntityModel, d as EntityProxy } from './index-DK2CXVZ8.cjs';
+import { f as IEntityUpdate, I as IEventData, E as EntityEventUid, b as IEntityEvent, i as IEntitySnapshot, h as IEntityRepository } from './entity-repository-awW_H993.cjs';
+import { I as IPipelineContext, a as IPipeline } from './pipeline-BowCAITe.cjs';
+import { I as Immutable } from './types-BNwBqRWY.cjs';
+import { IJsonSerializer, ILogger } from './utils/index.cjs';
+
+interface ISystemContextEntity {
+    readonly entity: Immutable<IEntity>;
+    readonly update: Immutable<IEntityUpdate>;
+    setEntity(entity: IEntity): void;
+    setUpdate(update: IEntityUpdate): void;
+}
+
+/**
+ * The ISystemContextEvents is the access point for Event related APIs.
+ * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.
+ */
+interface ISystemContextEvents {
+    /**
+     * Dispatches and schedules the Event to it's Subscribers or provided Entity Targets.
+     * @param data The EventData to dispatch.
+     * @param targets (optional) The Entities to send this event to. Providing this parameter will not broadcast this event.
+     */
+    dispatchEvent<TEventData extends IEventData>(data: TEventData, ...targets: IEntityProxy[]): void;
+    /**
+     * Dispatches and schedules the Events to their Subscribers or provided Entity Targets.
+     * @param data The EventData Array to dispatch.
+     * @param targets (optional) The Entities to send this event to. Providing this parameter will not broadcast this event.
+     */
+    dispatchEvents<TEventData extends IEventData>(data: TEventData[], ...targets: IEntityProxy[]): void;
+    /**
+     * Retrieves the Event with the given UID if it has been previously set on the current Context.
+     * @param uid The Event UID to retrieve.
+     */
+    getEvent<TEventData extends IEventData>(uid: EntityEventUid): IEntityEvent<TEventData>;
+    /**
+     * Retrieves all the Events currently set on the Context.
+     */
+    listEvents<TEventData extends IEventData>(): IEntityEvent<TEventData>[];
+    /**
+     * Returns whether the Event with the given UID has previously been set on the current Context.
+     * @param uid The Event UID to check for existence.
+     */
+    hasEvent(uid?: EntityEventUid): boolean;
+    /**
+     * Subscribes to Events with the given UID. When the matching Event is dispatched,
+     * the Entity update loop will set this Event on the Pipeline Context.
+     * @param uid The Event UID to subscribe to.
+     * @param filter (optional) Provides a callback function that will be executed on all matching Events.
+     * Can be used to filter what Event to schedule through to the current Entity update.
+     */
+    subscribeTo<TEventData extends IEventData>(uid: EntityEventUid, filter?: (event: IEntityEvent<TEventData>) => boolean): void;
+    /**
+     * Stops subscribing to Events with the given UID. The Entity will not receive any future Events with this UID.
+     * @param uid The Event UID to stop listening to.
+     */
+    unsubscribeFrom(uid: EntityEventUid): void;
+    /**
+     * Adds the given Events into the Context instance.
+     * @param events The Event instances to be set on the Context.
+     */
+    setContextEvents(events: IEntityEvent<IEventData>[]): void;
+    /**
+     * Adds the given Event into the Context instance.
+     * @param event The Event instance to be set on the Context.
+     */
+    setContextEvent(event: IEntityEvent<IEventData>): void;
+    /**
+     * Removes all the Events currently set on the Context instance.
+     */
+    clearContextEvents(): void;
+    /**
+     * Removes all the Event Subscriptions for the current Entity.
+     */
+    clearSubscriptions(): void;
+}
+
+/**
+ * The ISystemContextProxies is the access point for EntityProxy related APIs.
+ * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.
+ */
+interface ISystemContextProxies {
+    registerProxy(proxy: IEntityProxy, cleanup?: boolean): void;
+    registerProxies(proxies: IEntityProxy[], cleanup?: boolean): void;
+    removeProxy(proxy: IEntityProxy): void;
+    removeProxies(proxyEntityType?: EntityTypeUid): void;
+}
+
+/**
+ * The `ISystemContextRepository` is the access point for the `IEntityRepository` related APIs.
+ *
+ * The access is made in an `ISystemMiddleware` through the provided `ISystemPipelineContext`.
+ */
+interface ISystemContextRepository {
+    addEntity(entityType: EntityTypeUid, model: IEntityModel, snapshot?: IEntitySnapshot): void;
+    getEntity<TEntity extends IEntity>(proxy: EntityProxy<TEntity>): Immutable<TEntity>;
+    updateEntity(target?: IEntityProxy): void;
+    removeEntity(target: IEntityProxy): void;
+}
+
+/**
+ * The ISystemContextRepository is the access point for Scheduler related APIs.
+ * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.
+ */
+interface ISystemContextScheduler {
+    scheduleUpdate(target?: IEntityProxy, intervalMs?: number): void;
+    removeSchedule(target?: IEntityProxy): void;
+}
+
+/**
+ * The ISystemContextSnapshot is the access point for Snapshot related APIs.
+ * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.
+ */
+interface ISystemContextSnapshot {
+    readonly serializer: Immutable<IJsonSerializer>;
+    applyToEntity(snapshot: IEntitySnapshot): void;
+    createFromEntity(entity?: IEntity): IEntitySnapshot;
+    dispatchToUpdate(snapshot: IEntitySnapshot, proxy?: IEntityProxy): void;
+}
+
+/**
+ * The ISystemContext is the Context passed to a SystemMiddleware as part of the Pipeline Dispatch.
+ * It's an abstraction layer so that the Middleware code won't have explicit dependencies on other parts of the ECS.
+ *
+ * Any State changes done by the SystemMiddleware are executed using the APIs provided by the ISystemContext.
+ */
+interface ISystemContext<TEntity extends IEntity> extends IPipelineContext {
+    readonly deltaTimeMs: Immutable<number>;
+    readonly entity: Immutable<TEntity>;
+    readonly update: Immutable<IEntityUpdate>;
+    readonly events: Immutable<ISystemContextEvents>;
+    readonly proxies: Immutable<ISystemContextProxies>;
+    readonly repository: Immutable<ISystemContextRepository>;
+    readonly scheduler: Immutable<ISystemContextScheduler>;
+    readonly snapshot: Immutable<ISystemContextSnapshot>;
+    readonly logger: Immutable<ILogger>;
+}
+
+/**
+ * The built-in ECS pipeline types. They can be extended to introduce more types, and the System Runtime Pipeline should
+ * add Middleware to handle the newly added types.
+ */
+declare enum SystemType {
+    initialize = "initialize",
+    update = "update",
+    render = "render",
+    sync = "sync"
+}
+
+/**
+ * The ISystemsRuntimeContext is the Context passed by a SystemsRuntimePipeline.
+ * It helps orchestrate the execution of SystemPipelines registered in the SystemsModule.
+ */
+interface ISystemsRuntimeContext<TEntity extends IEntity> extends IPipelineContext {
+    readonly allowedSteps: Set<SystemType>;
+    readonly entityProvider: ISystemContextEntity;
+    readonly entityRepository: IEntityRepository;
+    readonly initEntity: (model: IEntityModel) => IEntity;
+    readonly systemPipelines: Map<SystemType, IPipeline<ISystemContext<TEntity>>>;
+    readonly systemContext: ISystemContext<TEntity>;
+}
+
+export { type ISystemsRuntimeContext as I, SystemType as S, type ISystemContext as a, type ISystemContextEntity as b, type ISystemContextEvents as c, type ISystemContextProxies as d, type ISystemContextRepository as e, type ISystemContextScheduler as f, type ISystemContextSnapshot as g };

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

@@ -0,0 +1,163 @@
+import { c as IEntity, I as IEntityProxy, E as EntityTypeUid, b as IEntityModel, d as EntityProxy } from './index-BPDsRt_F.js';
+import { f as IEntityUpdate, I as IEventData, E as EntityEventUid, b as IEntityEvent, i as IEntitySnapshot, h as IEntityRepository } from './entity-repository-Bu6rH-m5.js';
+import { I as IPipelineContext, a as IPipeline } from './pipeline-D43CXxWG.js';
+import { I as Immutable } from './types-BNwBqRWY.js';
+import { IJsonSerializer, ILogger } from './utils/index.js';
+
+interface ISystemContextEntity {
+    readonly entity: Immutable<IEntity>;
+    readonly update: Immutable<IEntityUpdate>;
+    setEntity(entity: IEntity): void;
+    setUpdate(update: IEntityUpdate): void;
+}
+
+/**
+ * The ISystemContextEvents is the access point for Event related APIs.
+ * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.
+ */
+interface ISystemContextEvents {
+    /**
+     * Dispatches and schedules the Event to it's Subscribers or provided Entity Targets.
+     * @param data The EventData to dispatch.
+     * @param targets (optional) The Entities to send this event to. Providing this parameter will not broadcast this event.
+     */
+    dispatchEvent<TEventData extends IEventData>(data: TEventData, ...targets: IEntityProxy[]): void;
+    /**
+     * Dispatches and schedules the Events to their Subscribers or provided Entity Targets.
+     * @param data The EventData Array to dispatch.
+     * @param targets (optional) The Entities to send this event to. Providing this parameter will not broadcast this event.
+     */
+    dispatchEvents<TEventData extends IEventData>(data: TEventData[], ...targets: IEntityProxy[]): void;
+    /**
+     * Retrieves the Event with the given UID if it has been previously set on the current Context.
+     * @param uid The Event UID to retrieve.
+     */
+    getEvent<TEventData extends IEventData>(uid: EntityEventUid): IEntityEvent<TEventData>;
+    /**
+     * Retrieves all the Events currently set on the Context.
+     */
+    listEvents<TEventData extends IEventData>(): IEntityEvent<TEventData>[];
+    /**
+     * Returns whether the Event with the given UID has previously been set on the current Context.
+     * @param uid The Event UID to check for existence.
+     */
+    hasEvent(uid?: EntityEventUid): boolean;
+    /**
+     * Subscribes to Events with the given UID. When the matching Event is dispatched,
+     * the Entity update loop will set this Event on the Pipeline Context.
+     * @param uid The Event UID to subscribe to.
+     * @param filter (optional) Provides a callback function that will be executed on all matching Events.
+     * Can be used to filter what Event to schedule through to the current Entity update.
+     */
+    subscribeTo<TEventData extends IEventData>(uid: EntityEventUid, filter?: (event: IEntityEvent<TEventData>) => boolean): void;
+    /**
+     * Stops subscribing to Events with the given UID. The Entity will not receive any future Events with this UID.
+     * @param uid The Event UID to stop listening to.
+     */
+    unsubscribeFrom(uid: EntityEventUid): void;
+    /**
+     * Adds the given Events into the Context instance.
+     * @param events The Event instances to be set on the Context.
+     */
+    setContextEvents(events: IEntityEvent<IEventData>[]): void;
+    /**
+     * Adds the given Event into the Context instance.
+     * @param event The Event instance to be set on the Context.
+     */
+    setContextEvent(event: IEntityEvent<IEventData>): void;
+    /**
+     * Removes all the Events currently set on the Context instance.
+     */
+    clearContextEvents(): void;
+    /**
+     * Removes all the Event Subscriptions for the current Entity.
+     */
+    clearSubscriptions(): void;
+}
+
+/**
+ * The ISystemContextProxies is the access point for EntityProxy related APIs.
+ * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.
+ */
+interface ISystemContextProxies {
+    registerProxy(proxy: IEntityProxy, cleanup?: boolean): void;
+    registerProxies(proxies: IEntityProxy[], cleanup?: boolean): void;
+    removeProxy(proxy: IEntityProxy): void;
+    removeProxies(proxyEntityType?: EntityTypeUid): void;
+}
+
+/**
+ * The `ISystemContextRepository` is the access point for the `IEntityRepository` related APIs.
+ *
+ * The access is made in an `ISystemMiddleware` through the provided `ISystemPipelineContext`.
+ */
+interface ISystemContextRepository {
+    addEntity(entityType: EntityTypeUid, model: IEntityModel, snapshot?: IEntitySnapshot): void;
+    getEntity<TEntity extends IEntity>(proxy: EntityProxy<TEntity>): Immutable<TEntity>;
+    updateEntity(target?: IEntityProxy): void;
+    removeEntity(target: IEntityProxy): void;
+}
+
+/**
+ * The ISystemContextRepository is the access point for Scheduler related APIs.
+ * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.
+ */
+interface ISystemContextScheduler {
+    scheduleUpdate(target?: IEntityProxy, intervalMs?: number): void;
+    removeSchedule(target?: IEntityProxy): void;
+}
+
+/**
+ * The ISystemContextSnapshot is the access point for Snapshot related APIs.
+ * The access is made in a SystemMiddleware through the provided ISystemPipelineContext.
+ */
+interface ISystemContextSnapshot {
+    readonly serializer: Immutable<IJsonSerializer>;
+    applyToEntity(snapshot: IEntitySnapshot): void;
+    createFromEntity(entity?: IEntity): IEntitySnapshot;
+    dispatchToUpdate(snapshot: IEntitySnapshot, proxy?: IEntityProxy): void;
+}
+
+/**
+ * The ISystemContext is the Context passed to a SystemMiddleware as part of the Pipeline Dispatch.
+ * It's an abstraction layer so that the Middleware code won't have explicit dependencies on other parts of the ECS.
+ *
+ * Any State changes done by the SystemMiddleware are executed using the APIs provided by the ISystemContext.
+ */
+interface ISystemContext<TEntity extends IEntity> extends IPipelineContext {
+    readonly deltaTimeMs: Immutable<number>;
+    readonly entity: Immutable<TEntity>;
+    readonly update: Immutable<IEntityUpdate>;
+    readonly events: Immutable<ISystemContextEvents>;
+    readonly proxies: Immutable<ISystemContextProxies>;
+    readonly repository: Immutable<ISystemContextRepository>;
+    readonly scheduler: Immutable<ISystemContextScheduler>;
+    readonly snapshot: Immutable<ISystemContextSnapshot>;
+    readonly logger: Immutable<ILogger>;
+}
+
+/**
+ * The built-in ECS pipeline types. They can be extended to introduce more types, and the System Runtime Pipeline should
+ * add Middleware to handle the newly added types.
+ */
+declare enum SystemType {
+    initialize = "initialize",
+    update = "update",
+    render = "render",
+    sync = "sync"
+}
+
+/**
+ * The ISystemsRuntimeContext is the Context passed by a SystemsRuntimePipeline.
+ * It helps orchestrate the execution of SystemPipelines registered in the SystemsModule.
+ */
+interface ISystemsRuntimeContext<TEntity extends IEntity> extends IPipelineContext {
+    readonly allowedSteps: Set<SystemType>;
+    readonly entityProvider: ISystemContextEntity;
+    readonly entityRepository: IEntityRepository;
+    readonly initEntity: (model: IEntityModel) => IEntity;
+    readonly systemPipelines: Map<SystemType, IPipeline<ISystemContext<TEntity>>>;
+    readonly systemContext: ISystemContext<TEntity>;
+}
+
+export { type ISystemsRuntimeContext as I, SystemType as S, type ISystemContext as a, type ISystemContextEntity as b, type ISystemContextEvents as c, type ISystemContextProxies as d, type ISystemContextRepository as e, type ISystemContextScheduler as f, type ISystemContextSnapshot as g };

package/dist/types-BNwBqRWY.d.cts

@@ -0,0 +1,22 @@
+type BooleanProps<T> = {
+    [Property in keyof T]: boolean;
+};
+type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+type MutableDeep<T> = {
+    -readonly [K in keyof T]: Mutable<T[K]>;
+};
+type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
+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>;
+type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
+type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+type ImmutableObject<T> = {
+    readonly [K in keyof T]: T[K];
+};
+type ImmutableObjectDeep<T> = {
+    readonly [K in keyof T]: Immutable<T[K]>;
+};
+
+export type { BooleanProps as B, Immutable as I, Mutable as M, MutableDeep as a, ImmutableArray as b, ImmutableMap as c, ImmutableSet as d, ImmutableObject as e, ImmutableObjectDeep as f };

package/dist/types-BNwBqRWY.d.ts

@@ -0,0 +1,22 @@
+type BooleanProps<T> = {
+    [Property in keyof T]: boolean;
+};
+type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+type MutableDeep<T> = {
+    -readonly [K in keyof T]: Mutable<T[K]>;
+};
+type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
+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>;
+type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
+type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+type ImmutableObject<T> = {
+    readonly [K in keyof T]: T[K];
+};
+type ImmutableObjectDeep<T> = {
+    readonly [K in keyof T]: Immutable<T[K]>;
+};
+
+export type { BooleanProps as B, Immutable as I, Mutable as M, MutableDeep as a, ImmutableArray as b, ImmutableMap as c, ImmutableSet as d, ImmutableObject as e, ImmutableObjectDeep as f };

package/dist/utils/index.cjs

@@ -0,0 +1,38 @@
+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/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  LogLevel: () => LogLevel
+});
+module.exports = __toCommonJS(utils_exports);
+
+// src/utils/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["trace"] = 0] = "trace";
+  LogLevel2[LogLevel2["debug"] = 1] = "debug";
+  LogLevel2[LogLevel2["warn"] = 2] = "warn";
+  LogLevel2[LogLevel2["error"] = 3] = "error";
+  return LogLevel2;
+})(LogLevel || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogLevel
+});
+//# sourceMappingURL=index.cjs.map

package/dist/utils/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/index.ts","../../src/utils/logger.ts"],"sourcesContent":["export * from \"./json-serializer\";\nexport * from \"./performance-timer\";\nexport * from \"./types\";\nexport * from \"./logger\";\n","/**\n * An ILogger instance allows printing messages to console or other targets.\n */\nexport interface ILogger {\n  log(level: LogLevel, message: any, ...args: any[]): void;\n\n  trace(message: any, ...args: any[]): void;\n  debug(message: any, ...args: any[]): void;\n  warn(message: any, ...args: any[]): void;\n  error(message: any, ...args: any[]): void;\n}\n\nexport enum LogLevel {\n  trace,\n  debug,\n  warn,\n  error,\n}\n\nexport interface ILoggerOptions {\n  enabled: Map<LogLevel, boolean>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACYO,IAAK,WAAL,kBAAKA,cAAL;AACL,EAAAA,oBAAA;AACA,EAAAA,oBAAA;AACA,EAAAA,oBAAA;AACA,EAAAA,oBAAA;AAJU,SAAAA;AAAA,GAAA;","names":["LogLevel"]}

package/dist/utils/index.d.cts

@@ -0,0 +1,32 @@
+export { I as IPerformanceTimer, P as PerformanceTimeEntry, a as PerformanceTimerUid } from '../performance-timer-XvdCbcAE.cjs';
+export { B as BooleanProps, I as Immutable, b as ImmutableArray, c as ImmutableMap, e as ImmutableObject, f as ImmutableObjectDeep, d as ImmutableSet, M as Mutable, a as MutableDeep } from '../types-BNwBqRWY.cjs';
+
+/**
+ * A custom `IJsonSerializer` implementation can provide different ways of serializing objects.
+ */
+interface IJsonSerializer {
+    serializeCustom(value: object): string;
+    parseCustom<TObject>(text: string): TObject;
+}
+
+/**
+ * An ILogger instance allows printing messages to console or other targets.
+ */
+interface ILogger {
+    log(level: LogLevel, message: any, ...args: any[]): void;
+    trace(message: any, ...args: any[]): void;
+    debug(message: any, ...args: any[]): void;
+    warn(message: any, ...args: any[]): void;
+    error(message: any, ...args: any[]): void;
+}
+declare enum LogLevel {
+    trace = 0,
+    debug = 1,
+    warn = 2,
+    error = 3
+}
+interface ILoggerOptions {
+    enabled: Map<LogLevel, boolean>;
+}
+
+export { type IJsonSerializer, type ILogger, type ILoggerOptions, LogLevel };

package/dist/utils/index.d.ts

@@ -1,4 +1,32 @@
-export * from "./json-serializer";
-export * from "./performance-timer";
-export * from "./types";
-export * from "./logger";
+export { I as IPerformanceTimer, P as PerformanceTimeEntry, a as PerformanceTimerUid } from '../performance-timer-XvdCbcAE.js';
+export { B as BooleanProps, I as Immutable, b as ImmutableArray, c as ImmutableMap, e as ImmutableObject, f as ImmutableObjectDeep, d as ImmutableSet, M as Mutable, a as MutableDeep } from '../types-BNwBqRWY.js';
+
+/**
+ * A custom `IJsonSerializer` implementation can provide different ways of serializing objects.
+ */
+interface IJsonSerializer {
+    serializeCustom(value: object): string;
+    parseCustom<TObject>(text: string): TObject;
+}
+
+/**
+ * An ILogger instance allows printing messages to console or other targets.
+ */
+interface ILogger {
+    log(level: LogLevel, message: any, ...args: any[]): void;
+    trace(message: any, ...args: any[]): void;
+    debug(message: any, ...args: any[]): void;
+    warn(message: any, ...args: any[]): void;
+    error(message: any, ...args: any[]): void;
+}
+declare enum LogLevel {
+    trace = 0,
+    debug = 1,
+    warn = 2,
+    error = 3
+}
+interface ILoggerOptions {
+    enabled: Map<LogLevel, boolean>;
+}
+
+export { type IJsonSerializer, type ILogger, type ILoggerOptions, LogLevel };