@perplexdotgg/mecs 0.5.0 → 0.5.1

package/README.md

@@ -16,7 +16,7 @@ MECS focuses on the developer's experience in their IDE, especially around auto-
 
 <details>
   <summary>Side note: Why not use SoA design?</summary>
-  While SoA can achieve better performance in the best cases, it tends to be unwieldy, especially for nested fields, and generally ECS implementations lack auto-complete for components and properties. For larger game projecting, remembering all component names and their properties is quite difficult. Using JS getters with SoA (to achieve auto complete) gives much worse overall performance than AoS.
+  While SoA can achieve better performance in the best cases, it tends to be unwieldy, especially for nested fields, and generally ECS implementations lack auto-complete for components and properties. For larger game projects, remembering all component names and their properties is quite difficult. Using JS getters with SoA (to achieve auto complete) gives much worse overall performance than AoS.
 </details>
 
 ---

package/build/index.d.ts

@@ -64,6 +64,16 @@ declare type ComponentMapInputListItems<CM extends ComponentMap> = Partial<{
     [K in keyof CM as LowercaseFirstLetter<K>]: ResolveEntityInputListItems<ComponentInput<ExtractMonomorphClass<CM[K]>>, CM>;
 }>;
 
+declare type ComponentsWithEntities<E, CM extends ComponentMap> = {
+    [K in keyof CM as ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? LowercaseFirstLetter<K> : never]: {
+        [Symbol.iterator](): IterableIterator<[WithPool<InstanceType<ExtractMonomorphClass<CM[K]>>>, E]>;
+    };
+};
+
+declare type ComponentsWithEntitiesCallable<E, CM extends ComponentMap> = ComponentsWithEntities<E, CM> & {
+    <Self extends abstract new (...args: any) => any>(this: Self): ComponentsWithEntities<InstanceType<Self>, CM>;
+};
+
 declare type ComponentTypeFromMonomorphClass<T> = T extends MonomorphClass<infer P, any, any> ? PropertyDefinitionClassProperties<P> : never;
 
 export declare function createEntityClass<C>(options?: EntityCodeGenerationOptions): <CM extends ComponentMap, QM extends QueryMap<CM>, I extends ComponentMapInput<CM> = ComponentMapInput<CM>>(componentMap: CM, queries?: QM) => EntityClassWithStatics<C, CM, QM, I>;
@@ -84,6 +94,8 @@ declare interface EntityBaseProperties<CM extends ComponentMap, I extends any =
     reset(data?: PartialRecursive<I>, updateQueryMemberships?: boolean, pool?: EntityPoolClass<this>): void;
     destroy(updateQueryMemberships?: boolean): void;
     isDestroyed(): boolean;
+    poolIndex: number;
+    pool: EntityPoolClass<this>;
 }
 
 export declare type EntityClass<CM extends ComponentMap, I extends ComponentMapInput<CM> = ComponentMapInput<CM>, QM extends QueryMap<CM> = QueryMap<CM>, E extends EntityInstance<CM, I> = EntityInstance<CM, I>> = EntityConstructor<QM, E, I, CM>;
@@ -121,11 +133,7 @@ export declare interface EntityConstructor<QM extends QueryMap<CM>, E extends En
     __typescriptOnlyInputType: I;
     pool: PoolCallable<E>;
     queries: QueriesCallable<E, QM, CM>;
-    componentsWithEntities: {
-        [K in keyof CM as ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? LowercaseFirstLetter<K> : never]: {
-            [Symbol.iterator](): IterableIterator<[WithPool<InstanceType<ExtractMonomorphClass<CM[K]>>>, E]>;
-        };
-    };
+    componentsWithEntities: ComponentsWithEntitiesCallable<E, CM>;
     components: {
         [K in keyof CM as ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? LowercaseFirstLetter<K> : never]: PoolClass<ExtractMonomorphClass<CM[K]>>;
     };

package/build/mecs.js

@@ -1033,9 +1033,23 @@ function getEntityClassCode(componentMap, queries, options) {
     theClass.componentToEntity = componentToEntity;
     theClass.componentIndices = componentIndices;
     theClass.components = componentPools;
-    theClass.componentsWithEntities = {
+
+    const componentsWithEntities = {
       ${componentWithEntityIteratorFunctionsCode}
     };
+    const componentsWithEntityCallable = new Proxy(function () { return componentsWithEntityCallable; }, {
+      get(_target, prop) {
+        if (prop in componentsWithEntities) {
+          return componentsWithEntities[prop];
+        }
+        return undefined;
+      },
+      set(_target, prop, value) {
+        componentsWithEntities[prop] = value;
+        return true;
+      },
+    });
+    theClass.componentsWithEntities = componentsWithEntityCallable;
 
     theClass.create = function(data, updateQueryMemberships = true, pool = this.pool) {
       if (pool.freeIndices.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@perplexdotgg/mecs",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "MECS - Monomorph ECS - A high-performance Entity Component System for TypeScript and JavaScript projects, designed for games and simulations.",
   "repository": {
     "type": "git",